tiny.smg.scan.scan_files

1const std = @import("std");2const sys = @import("sys");3const smg = @import("../root.zig");4const text = @import("../text/root.zig");56pub const ProjectIdentity = struct {7    digest: [std.crypto.hash.sha2.Sha256.digest_length]u8,8    files: usize,9};1011pub const SourceDigest = [std.crypto.hash.sha2.Sha256.digest_length]u8;1213pub const SourceIdentity = struct {14    path: []const u8,15    digest: SourceDigest,16};1718pub const ProjectState = struct {19    project: ProjectIdentity,20    sources: []const SourceIdentity,21};2223const ProjectIdentityBuilder = struct {24    hasher: std.crypto.hash.sha2.Sha256,2526    pub fn init(files: usize) ProjectIdentityBuilder {27        var hasher = std.crypto.hash.sha2.Sha256.init(.{});28        hasher.update("tiny.smg.project/v2\n");29        hashInteger(&hasher, files);30        return .{ .hasher = hasher };31    }3233    pub fn addSkipped(self: *ProjectIdentityBuilder, relative: []const u8) void {34        hashField(&self.hasher, relative);35        self.hasher.update(&.{0});36    }3738    pub fn addSource(self: *ProjectIdentityBuilder, relative: []const u8, digest: SourceDigest) void {39        hashField(&self.hasher, relative);40        self.hasher.update(&.{1});41        hashField(&self.hasher, &digest);42    }4344    pub fn finish(self: *ProjectIdentityBuilder) [std.crypto.hash.sha2.Sha256.digest_length]u8 {45        var digest: [std.crypto.hash.sha2.Sha256.digest_length]u8 = undefined;46        self.hasher.final(&digest);47        return digest;48    }49};5051pub fn sourceDigest(52    allocator: std.mem.Allocator,53    root: []const u8,54    relative: []const u8,55    module: []const u8,56    source: []const u8,57) !SourceDigest {58    var hasher = std.crypto.hash.sha2.Sha256.init(.{});59    hasher.update("tiny.smg.source-fragment/v1\n");60    hashField(&hasher, relative);61    hashField(&hasher, module);62    hashField(&hasher, source);63    if (std.mem.eql(u8, language(relative), "zig")) {64        try hashZigTargetModules(&hasher, allocator, root, relative, source);65    }66    var digest: SourceDigest = undefined;67    hasher.final(&digest);68    return digest;69}7071pub fn projectIdentity(72    allocator: std.mem.Allocator,73    phases: std.mem.Allocator,74    root: []const u8,75    explicit_excludes: []const []const u8,76    limits: smg.ScanLimits,77) !ProjectIdentity {78    return (try projectState(allocator, phases, root, explicit_excludes, limits)).project;79}8081pub fn projectState(82    allocator: std.mem.Allocator,83    phases: std.mem.Allocator,84    root: []const u8,85    explicit_excludes: []const []const u8,86    limits: smg.ScanLimits,87) !ProjectState {88    const excludes = try projectExcludes(allocator, root, explicit_excludes, limits);89    var files: std.ArrayList([]const u8) = .empty;90    try collectSupported(allocator, root, root, &files, excludes, limits);91    std.mem.sort([]const u8, files.items, {}, lessThan);92    var identity = ProjectIdentityBuilder.init(files.items.len);93    var sources: std.ArrayList(SourceIdentity) = .empty;94    try sources.ensureTotalCapacity(allocator, files.items.len);95    var scratch_arena = std.heap.ArenaAllocator.init(phases);96    defer scratch_arena.deinit();97    for (files.items) |relative| {98        _ = scratch_arena.reset(.retain_capacity);99        const scratch = scratch_arena.allocator();100        const absolute = try std.fs.path.join(scratch, &.{ root, relative });101        const source = text.readFileZ(102            scratch,103            absolute,104            limits.max_source_file_bytes,105        ) catch |err| switch (err) {106            error.StreamTooLong => return error.MaxSourceFileBytesExceeded,107            else => {108                identity.addSkipped(relative);109                continue;110            },111        };112        const module = try moduleName(scratch, root, relative);113        const digest = try sourceDigest(scratch, root, relative, module, source);114        identity.addSource(relative, digest);115        sources.appendAssumeCapacity(.{ .path = relative, .digest = digest });116    }117    return .{118        .project = .{119            .digest = identity.finish(),120            .files = files.items.len,121        },122        .sources = try sources.toOwnedSlice(allocator),123    };124}125126fn hashField(hasher: *std.crypto.hash.sha2.Sha256, value: []const u8) void {127    hashInteger(hasher, value.len);128    hasher.update(value);129}130131fn hashInteger(hasher: *std.crypto.hash.sha2.Sha256, value: anytype) void {132    var encoded: [@sizeOf(u64)]u8 = undefined;133    std.mem.writeInt(u64, &encoded, @intCast(value), .big);134    hasher.update(&encoded);135}136137fn hashZigTargetModules(138    hasher: *std.crypto.hash.sha2.Sha256,139    allocator: std.mem.Allocator,140    root: []const u8,141    relative_source: []const u8,142    source: []const u8,143) !void {144    const absolute_root = try std.fs.path.resolve(allocator, &.{root});145    const absolute_source = try std.fs.path.resolve(allocator, &.{ absolute_root, relative_source });146    const source_dir = std.fs.path.dirname(absolute_source) orelse absolute_root;147    var index: usize = 0;148    while (index < source.len) {149        if (source[index] != '"') {150            index += 1;151            continue;152        }153        const start = index + 1;154        index = start;155        while (index < source.len) : (index += 1) {156            if (source[index] == '\\') {157                index = @min(index + 1, source.len);158                continue;159            }160            if (source[index] != '"') continue;161            const raw = source[start..index];162            index += 1;163            if (!std.mem.endsWith(u8, raw, ".zig")) break;164            const absolute_target = try std.fs.path.resolve(165                allocator,166                &.{ absolute_root, source_dir, raw },167            );168            if (!pathWithinRoot(absolute_root, absolute_target)) break;169            var relative = absolute_target[absolute_root.len..];170            while (relative.len != 0 and std.fs.path.isSep(relative[0])) relative = relative[1..];171            hasher.update("zig-target\n");172            hashField(hasher, relative);173            hashField(hasher, try moduleName(allocator, absolute_root, relative));174            break;175        }176    }177}178179pub fn collectSupported(180    allocator: std.mem.Allocator,181    root: []const u8,182    path: []const u8,183    files: *std.ArrayList([]const u8),184    excludes: []const []const u8,185    limits: smg.ScanLimits,186) !void {187    const stat = statPath(path) catch return;188    if (stat.kind == .directory) {189        if (try shouldSkip(allocator, root, path, excludes)) return;190        if (try collectGitSupported(allocator, root, path, files, excludes, limits)) return;191        try collectFilesystemSupported(allocator, root, path, files, excludes, limits);192        return;193    }194    if (stat.kind != .file) return;195    if (!supported(path) or try shouldSkip(allocator, root, path, excludes)) return;196    try appendUnique(allocator, files, try relativePath(allocator, root, path));197}198199fn collectGitSupported(200    allocator: std.mem.Allocator,201    root: []const u8,202    path: []const u8,203    files: *std.ArrayList([]const u8),204    excludes: []const []const u8,205    limits: smg.ScanLimits,206) !bool {207    const repository = try smg.git.run(208        allocator,209        root,210        &.{ "git", "rev-parse", "--is-inside-work-tree" },211        64,212    );213    if (!repository.ok or !std.mem.eql(u8, std.mem.trim(u8, repository.stdout, " \t\r\n"), "true")) return false;214    const pathspec = try gitPathspec(allocator, root, path) orelse return false;215    const listed = smg.git.run(216        allocator,217        root,218        &.{ "git", "--literal-pathspecs", "ls-files", "--cached", "--others", "--exclude-standard", "--deduplicate", "-z", "--", pathspec },219        limits.max_git_file_list_bytes,220    ) catch |err| switch (err) {221        error.StreamTooLong => return error.MaxGitFileListBytesExceeded,222        else => return err,223    };224    if (!listed.ok) return error.GitFileDiscoveryFailed;225    var paths = std.mem.splitScalar(u8, listed.stdout, 0);226    while (paths.next()) |relative| {227        if (relative.len == 0) continue;228        const absolute = try std.fs.path.join(allocator, &.{ root, relative });229        const stat = statPath(absolute) catch continue;230        if (stat.kind != .file or !supported(relative) or try shouldSkip(allocator, root, absolute, excludes)) continue;231        try appendUnique(allocator, files, relative);232    }233    return true;234}235236fn gitPathspec(allocator: std.mem.Allocator, root: []const u8, path: []const u8) !?[]const u8 {237    const absolute_root = try sys.fs.realPathAlloc(allocator, root);238    const absolute_path = try sys.fs.realPathAlloc(allocator, path);239    if (!pathWithinRoot(absolute_root, absolute_path)) return null;240    var relative = absolute_path[absolute_root.len..];241    while (relative.len != 0 and (relative[0] == '/' or relative[0] == '\\')) relative = relative[1..];242    return if (relative.len == 0) "." else relative;243}244245fn pathWithinRoot(root: []const u8, path: []const u8) bool {246    if (std.mem.eql(u8, root, path)) return true;247    return path.len > root.len and248        std.mem.startsWith(u8, path, root) and249        (path[root.len] == '/' or path[root.len] == '\\');250}251252fn collectFilesystemSupported(253    allocator: std.mem.Allocator,254    root: []const u8,255    path: []const u8,256    files: *std.ArrayList([]const u8),257    excludes: []const []const u8,258    limits: smg.ScanLimits,259) !void {260    const entries = sys.fs.listDirAlloc(allocator, path) catch return;261    for (entries) |entry| {262        const stat = statPath(entry.path) catch continue;263        if (stat.kind == .directory) {264            if (!try shouldSkip(allocator, root, entry.path, excludes)) {265                try collectFilesystemSupported(266                    allocator,267                    root,268                    entry.path,269                    files,270                    excludes,271                    limits,272                );273            }274        } else if (stat.kind == .file and supported(entry.path) and !try shouldSkip(allocator, root, entry.path, excludes)) {275            try appendUnique(allocator, files, try relativePath(allocator, root, entry.path));276        }277    }278}279280pub fn projectExcludes(281    allocator: std.mem.Allocator,282    root: []const u8,283    explicit: []const []const u8,284    limits: smg.ScanLimits,285) ![]const []const u8 {286    const path = try std.fs.path.join(allocator, &.{ root, smg.storage.paths.ignore_relative_path });287    const source = sys.fs.readFileAlloc(288        allocator,289        path,290        limits.max_ignore_file_bytes,291    ) catch |err| switch (err) {292        error.FileNotFound, error.NotDir => return explicit,293        else => return err,294    };295    var count = explicit.len;296    var lines = std.mem.splitScalar(u8, source, '\n');297    while (lines.next()) |line| {298        if (ignorePattern(line) != null) count += 1;299    }300    if (count == explicit.len) return explicit;301    const excludes = try allocator.alloc([]const u8, count);302    @memcpy(excludes[0..explicit.len], explicit);303    var index = explicit.len;304    lines.reset();305    while (lines.next()) |line| {306        const pattern = ignorePattern(line) orelse continue;307        excludes[index] = pattern;308        index += 1;309    }310    std.debug.assert(index == excludes.len);311    return excludes;312}313314pub fn statPath(path: []const u8) std.Io.Dir.StatFileError!std.Io.Dir.Stat {315    return sys.fs.cwd().statFile(316        sys.fs.debugIo(),317        path,318        .{ .follow_symlinks = false },319    );320}321322pub fn appendUnique(allocator: std.mem.Allocator, paths: *std.ArrayList([]const u8), path: []const u8) !void {323    if (!contains(paths.items, path)) try paths.append(allocator, path);324}325326pub fn contains(paths: []const []const u8, path: []const u8) bool {327    for (paths) |item| if (std.mem.eql(u8, item, path)) return true;328    return false;329}330331pub fn underPrefixes(prefixes: []const []const u8, file: []const u8) bool {332    for (prefixes) |prefix| {333        if (std.mem.eql(u8, prefix, ".") or std.mem.startsWith(u8, file, prefix)) return true;334    }335    return false;336}337338pub fn relativePath(allocator: std.mem.Allocator, root: []const u8, path: []const u8) ![]const u8 {339    var rel = path;340    if (std.fs.path.isAbsolute(path) and std.mem.startsWith(u8, path, root)) {341        rel = path[root.len..];342        while (rel.len != 0 and (rel[0] == '/' or rel[0] == '\\')) rel = rel[1..];343    }344    while (std.mem.startsWith(u8, rel, "./")) rel = rel[2..];345    return try text.replaceSeparators(allocator, rel, '/');346}347348pub fn moduleName(allocator: std.mem.Allocator, root: []const u8, rel_path: []const u8) ![]const u8 {349    if (try workspaceModuleName(allocator, root, rel_path)) |name| return name;350    var rel = rel_path;351    while (std.mem.startsWith(u8, rel, "./")) rel = rel[2..];352    if (std.mem.startsWith(u8, rel, "src/")) {353        const rest = rel["src/".len..];354        const slash = std.mem.indexOfScalar(u8, rest, '/');355        if (slash) |index| {356            const package = rest[0..index];357            const candidate = try std.fs.path.join(allocator, &.{ root, "src", package });358            const init_file = try std.fs.path.join(allocator, &.{ candidate, "__init__.py" });359            const package_json = try std.fs.path.join(allocator, &.{ root, "package.json" });360            const tsconfig = try std.fs.path.join(allocator, &.{ root, "tsconfig.json" });361            if (sys.fs.exists(init_file) or sys.fs.exists(package_json) or sys.fs.exists(tsconfig)) {362                rel = rest;363            }364        }365    }366    return try moduleNameFromRel(allocator, "", rel);367}368369pub fn isPackageFile(path: []const u8) bool {370    const stem = removeKnownExtension(text.basename(path));371    return std.mem.eql(u8, stem, "__init__") or std.mem.eql(u8, stem, "index");372}373374pub fn removeKnownExtension(path: []const u8) []const u8 {375    const extensions = [_][]const u8{ ".py", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".zig", ".chic", ".c", ".h", ".cpp", ".hpp", ".cc", ".cxx", ".hh", ".hxx", ".cu", ".cuh", ".metal" };376    for (extensions) |ext| {377        if (std.mem.endsWith(u8, path, ext)) return path[0 .. path.len - ext.len];378    }379    return path;380}381382pub fn language(path: []const u8) []const u8 {383    if (std.mem.endsWith(u8, path, ".py")) return "python";384    if (std.mem.endsWith(u8, path, ".zig")) return "zig";385    if (std.mem.endsWith(u8, path, ".chic")) return "chiclet";386    if (std.mem.endsWith(u8, path, ".ts") or std.mem.endsWith(u8, path, ".tsx")) return "typescript";387    if (std.mem.endsWith(u8, path, ".h")) return "c_header";388    if (std.mem.endsWith(u8, path, ".cpp") or std.mem.endsWith(u8, path, ".cc") or std.mem.endsWith(u8, path, ".cxx") or std.mem.endsWith(u8, path, ".cu") or std.mem.endsWith(u8, path, ".metal")) return "cpp";389    if (std.mem.endsWith(u8, path, ".hpp") or std.mem.endsWith(u8, path, ".hh") or std.mem.endsWith(u8, path, ".hxx") or std.mem.endsWith(u8, path, ".cuh")) return "cpp_header";390    if (std.mem.endsWith(u8, path, ".c")) return "c";391    return "javascript";392}393394pub fn displayName(lang: []const u8) []const u8 {395    if (std.mem.eql(u8, lang, "python")) return "Python";396    if (std.mem.eql(u8, lang, "zig")) return "Zig";397    if (std.mem.eql(u8, lang, "chiclet")) return "Chiclet";398    if (std.mem.eql(u8, lang, "typescript")) return "TypeScript";399    if (std.mem.eql(u8, lang, "c")) return "C";400    if (std.mem.eql(u8, lang, "c_header")) return "CHeader";401    if (std.mem.eql(u8, lang, "cpp")) return "Cpp";402    if (std.mem.eql(u8, lang, "cpp_header")) return "CppHeader";403    return "JavaScript";404}405406pub fn supported(path: []const u8) bool {407    return std.mem.endsWith(u8, path, ".py") or408        std.mem.endsWith(u8, path, ".zig") or409        std.mem.endsWith(u8, path, ".chic") or410        std.mem.endsWith(u8, path, ".c") or411        std.mem.endsWith(u8, path, ".h") or412        std.mem.endsWith(u8, path, ".cc") or413        std.mem.endsWith(u8, path, ".cpp") or414        std.mem.endsWith(u8, path, ".hpp") or415        std.mem.endsWith(u8, path, ".cxx") or416        std.mem.endsWith(u8, path, ".hh") or417        std.mem.endsWith(u8, path, ".hxx") or418        std.mem.endsWith(u8, path, ".cu") or419        std.mem.endsWith(u8, path, ".cuh") or420        std.mem.endsWith(u8, path, ".metal") or421        std.mem.endsWith(u8, path, ".js") or422        std.mem.endsWith(u8, path, ".jsx") or423        std.mem.endsWith(u8, path, ".mjs") or424        std.mem.endsWith(u8, path, ".cjs") or425        std.mem.endsWith(u8, path, ".ts") or426        std.mem.endsWith(u8, path, ".tsx");427}428429pub fn shouldSkip(allocator: std.mem.Allocator, root: []const u8, path: []const u8, excludes: []const []const u8) !bool {430    const rel = try relativePath(allocator, root, path);431    if (skip(rel)) return true;432    if (excludes.len == 0) return false;433    return excluded(rel, excludes);434}435436pub fn lessThan(_: void, a: []const u8, b: []const u8) bool {437    return std.mem.lessThan(u8, a, b);438}439440fn workspaceModuleName(allocator: std.mem.Allocator, root: []const u8, rel_path: []const u8) !?[]const u8 {441    var current = std.fs.path.dirname(rel_path) orelse "";442    while (true) {443        const package_json = if (current.len == 0)444            try std.fs.path.join(allocator, &.{ root, "package.json" })445        else446            try std.fs.path.join(allocator, &.{ root, current, "package.json" });447        if (try loadPackageName(allocator, package_json)) |package_name| {448            const package_rel = if (current.len == 0) rel_path else rel_path[current.len + 1 ..];449            return try moduleNameFromRel(allocator, package_name, package_rel);450        }451        if (current.len == 0) break;452        current = std.fs.path.dirname(current) orelse "";453    }454    return null;455}456457fn loadPackageName(allocator: std.mem.Allocator, path: []const u8) !?[]const u8 {458    const raw = text.readFile(allocator, path, 1024 * 1024) catch return null;459    const parsed = std.json.parseFromSlice(std.json.Value, allocator, raw, .{}) catch return null;460    const object = switch (parsed.value) {461        .object => |object| object,462        else => return null,463    };464    const value = object.get("name") orelse return null;465    const name = switch (value) {466        .string => |string| text.trim(string),467        else => return null,468    };469    if (name.len == 0) return null;470    var normalized = if (name[0] == '@') name[1..] else name;471    normalized = try text.replaceSeparators(allocator, normalized, '.');472    return normalized;473}474475test "project identity covers source bytes and computed module identity" {476    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);477    defer arena.deinit();478    const allocator = arena.allocator();479    const root = try std.fmt.allocPrint(allocator, "/tmp/smg-project-identity-test-{x}", .{@intFromPtr(&arena)});480    defer sys.fs.deleteTree(root) catch {};481    try sys.fs.createDirPath(try std.fs.path.join(allocator, &.{ root, "src", "app" }));482    try sys.fs.createDirPath(try std.fs.path.join(allocator, &.{ root, "ignored" }));483    const source_path = try std.fs.path.join(allocator, &.{ root, "src", "app", "service.zig" });484    const package_path = try std.fs.path.join(allocator, &.{ root, "package.json" });485    const target_package_path = try std.fs.path.join(allocator, &.{ root, "ignored", "package.json" });486    try text.writeFile(source_path, "const target = @import(\"../../ignored/target.zig\");\npub fn value() u8 { return 1; }\n");487    try text.writeFile(package_path, "{\"name\":\"first\"}\n");488    try text.writeFile(target_package_path, "{\"name\":\"first-target\"}\n");489    try text.writeFile(try std.fs.path.join(allocator, &.{ root, "ignored", "target.zig" }), "pub const value: u8 = 1;\n");490    try text.writeFile(try std.fs.path.join(allocator, &.{ root, smg.storage.paths.ignore_relative_path }), "ignored.zig\nignored\n__init__.py\n");491492    const initial = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);493    try text.writeFile(source_path, "const target = @import(\"../../ignored/target.zig\");\npub fn value() u8 { return 2; }\n");494    const edited = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);495    try std.testing.expect(!std.mem.eql(u8, &initial.digest, &edited.digest));496    try text.writeFile(source_path, "const target = @import(\"../../ignored/target.zig\");\npub fn value() u8 { return 1; }\n");497    const reverted = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);498    try std.testing.expectEqualSlices(u8, &initial.digest, &reverted.digest);499500    try text.writeFile(package_path, "{\"name\":\"second\"}\n");501    const renamed = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);502    try std.testing.expect(!std.mem.eql(u8, &initial.digest, &renamed.digest));503504    try text.writeFile(package_path, "{\"name\":\"first\"}\n");505    const ignored_path = try std.fs.path.join(allocator, &.{ root, "ignored.zig" });506    try text.writeFile(ignored_path, "pub fn ignored() u8 { return 1; }\n");507    const ignored = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);508    try std.testing.expectEqualSlices(u8, &initial.digest, &ignored.digest);509    try text.writeFile(ignored_path, "pub fn ignored() u8 { return 2; }\n");510    const ignored_edited = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);511    try std.testing.expectEqualSlices(u8, &initial.digest, &ignored_edited.digest);512513    try text.writeFile(target_package_path, "{\"name\":\"second-target\"}\n");514    const target_renamed = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);515    try std.testing.expect(!std.mem.eql(u8, &initial.digest, &target_renamed.digest));516517    try text.writeFile(target_package_path, "{\"name\":\"first-target\"}\n");518    const extra_path = try std.fs.path.join(allocator, &.{ root, "src", "app", "extra.py" });519    try text.writeFile(extra_path, "def extra():\n    return 1\n");520    const added = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);521    try std.testing.expect(!std.mem.eql(u8, &initial.digest, &added.digest));522    try sys.fs.deleteFile(extra_path);523    const deleted = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);524    try std.testing.expectEqualSlices(u8, &initial.digest, &deleted.digest);525526    try sys.fs.deleteFile(package_path);527    const without_config = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);528    const tsconfig_path = try std.fs.path.join(allocator, &.{ root, "tsconfig.json" });529    try text.writeFile(tsconfig_path, "{}\n");530    const with_tsconfig = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);531    try std.testing.expect(!std.mem.eql(u8, &without_config.digest, &with_tsconfig.digest));532    try sys.fs.deleteFile(tsconfig_path);533    const marker_path = try std.fs.path.join(allocator, &.{ root, "src", "app", "__init__.py" });534    try text.writeFile(marker_path, "");535    const with_ignored_marker = try projectIdentity(allocator, allocator, root, &.{}, smg.default_limits.scan);536    try std.testing.expect(!std.mem.eql(u8, &without_config.digest, &with_ignored_marker.digest));537}538539fn moduleNameFromRel(allocator: std.mem.Allocator, prefix: []const u8, rel_raw: []const u8) ![]const u8 {540    var rel = rel_raw;541    if (prefix.len != 0 and std.mem.startsWith(u8, rel, "src/")) rel = rel["src/".len..];542    const without_ext = removeKnownExtension(rel);543    var dotted = try text.replaceSeparators(allocator, without_ext, '.');544    while (std.mem.startsWith(u8, dotted, ".")) dotted = dotted[1..];545    if (std.mem.endsWith(u8, dotted, ".__init__")) dotted = dotted[0 .. dotted.len - ".__init__".len];546    if (std.mem.endsWith(u8, dotted, ".index")) dotted = dotted[0 .. dotted.len - ".index".len];547    if (std.mem.eql(u8, dotted, "__init__") or std.mem.eql(u8, dotted, "index")) dotted = "";548    if (prefix.len == 0) return if (dotted.len == 0) try allocator.dupe(u8, "root") else dotted;549    if (dotted.len == 0) return prefix;550    return try std.fmt.allocPrint(allocator, "{s}.{s}", .{ prefix, dotted });551}552553fn skip(path: []const u8) bool {554    const parts = [_][]const u8{ ".git", ".smg", ".claude", ".codex", ".zig-cache", "zig-cache", "zig-out", ".venv", "venv", ".env", "node_modules", "__pycache__", ".mypy_cache", ".pytest_cache", ".ruff_cache", ".hypothesis", ".tox", "dist", "site-packages", "vendor", "third_party" };555    var split = std.mem.splitAny(u8, path, "/\\");556    while (split.next()) |part| {557        for (parts) |skip_part| if (std.mem.eql(u8, part, skip_part)) return true;558    }559    return false;560}561562fn excluded(rel: []const u8, excludes: []const []const u8) bool {563    for (excludes) |raw| {564        const pattern = trimExcludePattern(raw);565        if (pattern.len == 0) continue;566        if (std.mem.indexOfAny(u8, pattern, "/\\") == null) {567            var parts = std.mem.splitAny(u8, rel, "/\\");568            while (parts.next()) |part| if (globMatch(part, pattern)) return true;569        } else if (pathOrAncestorMatches(rel, pattern)) {570            return true;571        }572    }573    return false;574}575576fn pathOrAncestorMatches(path: []const u8, pattern: []const u8) bool {577    var end = path.len;578    while (true) {579        if (globMatch(path[0..end], pattern)) return true;580        end = std.mem.lastIndexOfAny(u8, path[0..end], "/\\") orelse return false;581    }582}583584fn trimExcludePattern(raw: []const u8) []const u8 {585    var pattern = std.mem.trim(u8, raw, " \t\r\n");586    while (std.mem.startsWith(u8, pattern, "./")) pattern = pattern[2..];587    while (std.mem.startsWith(u8, pattern, "/")) pattern = pattern[1..];588    while (std.mem.endsWith(u8, pattern, "/")) pattern = pattern[0 .. pattern.len - 1];589    return pattern;590}591592fn ignorePattern(raw: []const u8) ?[]const u8 {593    const pattern = trimExcludePattern(raw);594    if (pattern.len == 0 or pattern[0] == '#') return null;595    return pattern;596}597598fn globMatch(value: []const u8, pattern: []const u8) bool {599    var value_index: usize = 0;600    var pattern_index: usize = 0;601    var star_index: ?usize = null;602    var retry_index: usize = 0;603    while (value_index < value.len) {604        if (pattern_index < pattern.len and (normalizedPathByte(pattern[pattern_index]) == normalizedPathByte(value[value_index]) or pattern[pattern_index] == '?')) {605            value_index += 1;606            pattern_index += 1;607        } else if (pattern_index < pattern.len and pattern[pattern_index] == '*') {608            star_index = pattern_index;609            retry_index = value_index;610            pattern_index += 1;611        } else if (star_index) |star| {612            pattern_index = star + 1;613            retry_index += 1;614            value_index = retry_index;615        } else {616            return false;617        }618    }619    while (pattern_index < pattern.len and pattern[pattern_index] == '*') pattern_index += 1;620    return pattern_index == pattern.len;621}622623fn normalizedPathByte(byte: u8) u8 {624    return if (byte == '\\') '/' else byte;625}

1pub const scan_files = @import("files.zig");