@isomorph.ai/cli 0.10.2 → 0.10.3

package/dist/packages/harbour-cli/src/deploy.js

@@ -227,10 +227,9 @@ async function ensureChecksPassed(root, output, options) {
     }
     else if (previous) {
         // Name the paths. Without them the line is true but unactionable: a
-        // builder whose agent wrote scratch files into a gitignored folder inside
-        // the app root hit this three times before finding the folder, because
-        // everything inside the root is inside the deployment boundary whether git
-        // tracks it or not.
+        // builder whose agent wrote scratch files into the app root hit this three
+        // times before finding the folder. (A gitignored folder is outside the
+        // boundary now, so writes there no longer invalidate the checks at all.)
         const moved = describeSourceChange(previous.sourceFiles, tree.entries);
         output(`The app's code has changed since its checks last ran${moved ? ` (${moved})` : ""}; running the checks first.`);
     }

package/dist/packages/harbour-cli/src/kit.js

@@ -270,10 +270,10 @@ export async function sourceDigest(root) {
  * What moved between the tree the checks ran on and the tree being deployed.
  *
  * A builder hit this three times in one session: their agent wrote scratch files
- * into a gitignored folder inside the app root, which is still inside the
- * deployment boundary, so every write invalidated the checks. The refusal named
- * the code but not the path, so nothing pointed at the folder. Naming the paths
- * is the whole fix.
+ * into a folder inside the app root, so every write invalidated the checks. The
+ * refusal named the code but not the path, so nothing pointed at the folder.
+ * Naming the paths is the fix for files inside the boundary; a gitignored folder
+ * is outside it now, so those writes no longer invalidate the checks.
  */
 export function describeSourceChange(before, after) {
     if (!before)

package/dist/src/analyzer.js

@@ -2,11 +2,33 @@ import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { lstat, readFile, readdir, stat } from "node:fs/promises";
-import { basename, dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { parseGitIgnore } from "./gitignore.js";
 import { sha256 } from "./digest.js";
 import { isEnvExamplePath, isKitCommittedPath, isSourceIntakeExcludedPath } from "./secret-paths.js";
 const ANALYZER_VERSION = "0.1.0";
-const MAX_FILES = 600;
+/**
+ * The deployable boundary is every file under the app root minus the ignored
+ * directories and minus what the root `.gitignore` says, up to MAX_FILES.
+ *
+ * Reaching the limit is an error, never a truncation. The walk is alphabetical,
+ * so a silent cut is purely lexicographic: on op harbour-fourier-2af9aaad
+ * (2026-09-23) a 600-file cap filled up inside docs/ and the package shipped
+ * with no src/ and no package.json, and nothing but an "unknown" said so.
+ *
+ * 1,500 is what the records can carry today: the CLI's preliminary manifest
+ * (path, bytes, sha256 per file) is stored whole inside the SOURCE_UPLOAD
+ * DynamoDB item, about 210 bytes per file against the 400 KB item limit.
+ * Raising this to the ZIP path's 5,000 needs that manifest moved to S3 first.
+ */
+const MAX_FILES = 1_500;
+/**
+ * The env-name scan has its OWN budget, above the packaging cap: a name that
+ * never becomes a candidate is never evidenced, never classified and never
+ * asked (a 691-file app once lost its Stripe keys to the packaging cut).
+ * 5,000 matches the ZIP and git-import limits.
+ */
+const MAX_ENV_SCAN_FILES = 5_000;
 const MAX_FILE_BYTES = 256_000;
 // The pipeline's own receipts and derived artifacts (`.harbour/`, written into
 // the workspace and the published lineage) are control-plane artifacts, not
@@ -17,7 +39,7 @@ const IGNORED_DIRS = new Set([".git", ".harbour", ".isomorph", ".next", ".nuxt",
 const KIT_DIR = ".isomorph";
 const KIT_CONTROL_FILES = [`${KIT_DIR}/integrations.json`, `${KIT_DIR}/kit.lock.json`, `${KIT_DIR}/app.json`];
 const SECRET_FILE_NAMES = new Set([".env", ".env.local", ".env.production", ".env.development", ".npmrc"]);
-const TEXT_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".json", ".html", ".css", ".py", ".rb", ".go", ".rs", ".java", ".cs", ".php", ".md", ".toml", ".yaml", ".yml", ".sh"]);
+const TEXT_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".json", ".html", ".css", ".py", ".rb", ".go", ".rs", ".java", ".cs", ".php", ".md", ".toml", ".yaml", ".yml", ".sh", ".vue", ".svelte", ".astro", ".mts", ".cts"]);
 function normalizeIncludePath(value) {
     if (!value || value === ".")
         return "";
@@ -28,7 +50,7 @@ function normalizeIncludePath(value) {
         throw new Error("ANALYZER_INCLUDE_INVALID: include paths may not contain traversal segments.");
     return parts.join("/");
 }
-async function collectIncludedFiles(root, includePaths, output, unknowns) {
+async function collectIncludedFiles(root, includePaths, output, filter) {
     const normalized = [...new Set(includePaths.map(normalizeIncludePath))];
     for (const include of normalized) {
         if (include.split("/").some(part => IGNORED_DIRS.has(part)) && !isKitCommittedPath(include))
@@ -53,8 +75,8 @@ async function collectIncludedFiles(root, includePaths, output, unknowns) {
                 throw new Error(`ANALYZER_INCLUDE_UNSAFE: symlink path component is not allowed: ${include}`);
         }
         if (info.isDirectory())
-            await collectFiles(root, absolute, output, unknowns);
-        else
+            await collectFiles(root, absolute, output, filter);
+        else if (!isGitIgnored(filter, root, absolute, false))
             await collectFile(root, absolute, output);
     }
 }
@@ -62,30 +84,116 @@ function extension(path) {
     const index = path.lastIndexOf(".");
     return index >= 0 ? path.slice(index) : "";
 }
-async function collectFiles(root, current, output, unknowns) {
-    if (output.length >= MAX_FILES)
-        return;
+/**
+ * The builder's own `.gitignore` at the app root is the statement of what is
+ * not the app: research dumps, exports, caches. It is what a git import would
+ * leave out too, so the ZIP path and the git path agree on the boundary.
+ * Nested ignore files are not read. A missing file adds no rules.
+ */
+async function loadGitIgnore(root) {
+    let content = "";
+    try {
+        content = await readFile(join(root, ".gitignore"), "utf8");
+    }
+    catch { /* no .gitignore: nothing extra is ignored */ }
+    return parseGitIgnore(content);
+}
+function isGitIgnored(filter, root, absolute, isDirectory) {
+    const path = relative(root, absolute).split(sep).join("/");
+    if (!path)
+        return false;
+    return filter.ignores(path, isDirectory);
+}
+/**
+ * Which directories filled the boundary, for the error a builder reads when
+ * the limit is hit: the top-level names with the most collected files.
+ */
+function fileLimitError(output) {
+    const counts = new Map();
+    for (const file of output) {
+        const top = file.path.includes("/") ? `${file.path.slice(0, file.path.indexOf("/"))}/` : file.path;
+        counts.set(top, (counts.get(top) ?? 0) + 1);
+    }
+    const largest = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name, count]) => `${name} (${count})`).join(", ");
+    return new Error(`ANALYZER_FILE_LIMIT_EXCEEDED: the app root holds more than ${MAX_FILES} files. Most are under: ${largest}. Add folders that are not part of the app to .gitignore and run again.`);
+}
+async function collectFiles(root, current, output, filter) {
     const entries = await readdir(current, { withFileTypes: true });
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-        if (output.length >= MAX_FILES) {
-            unknowns.push(`file limit reached at ${MAX_FILES} files`);
-            return;
-        }
         // A linked worktree represents .git as a small pointer file rather than a
         // directory. It is Git metadata and must stay outside the app boundary in
         // both checkout layouts.
         if (entry.name === ".git")
             continue;
+        const absolute = join(current, entry.name);
+        if (entry.isDirectory()) {
+            if (IGNORED_DIRS.has(entry.name)) {
+                if (entry.name === KIT_DIR && current === root)
+                    await collectKitFiles(root, output);
+                continue;
+            }
+            if (isGitIgnored(filter, root, absolute, true))
+                continue;
+            await collectFiles(root, absolute, output, filter);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (isGitIgnored(filter, root, absolute, false))
+            continue;
+        if (output.length >= MAX_FILES)
+            throw fileLimitError(output);
+        await collectFile(root, absolute, output);
+    }
+}
+/**
+ * A second, name-only walk for environment-variable detection. It reads the
+ * same file types under the same ignore rules, but carries no packaging
+ * meaning and no per-file bookkeeping, so it can afford a much larger budget.
+ */
+async function collectEnvScanFiles(root, current, output, filter) {
+    if (output.length >= MAX_ENV_SCAN_FILES)
+        return;
+    let entries;
+    try {
+        entries = await readdir(current, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (output.length >= MAX_ENV_SCAN_FILES)
+            return;
+        if (entry.name === ".git")
+            continue;
+        const absolute = join(current, entry.name);
         if (entry.isDirectory()) {
-            if (!IGNORED_DIRS.has(entry.name))
-                await collectFiles(root, join(current, entry.name), output, unknowns);
-            else if (entry.name === KIT_DIR && current === root)
-                await collectKitFiles(root, output);
+            if (!IGNORED_DIRS.has(entry.name) && !isGitIgnored(filter, root, absolute, true))
+                await collectEnvScanFiles(root, absolute, output, filter);
             continue;
         }
         if (!entry.isFile())
             continue;
-        await collectFile(root, join(current, entry.name), output);
+        if (isGitIgnored(filter, root, absolute, false))
+            continue;
+        const name = entry.name;
+        if (SECRET_FILE_NAMES.has(name))
+            continue;
+        if (!TEXT_EXTENSIONS.has(extension(name)) && !isEnvTemplateFile(name) && !isShellContextFile(name))
+            continue;
+        let info;
+        try {
+            info = await lstat(absolute);
+        }
+        catch {
+            continue;
+        }
+        if (!info.isFile() || info.isSymbolicLink() || info.size > MAX_FILE_BYTES)
+            continue;
+        try {
+            output.push({ path: relative(root, absolute), basename: name, size: info.size, content: await readFile(absolute, "utf8") });
+        }
+        catch { /* unreadable file contributes no names */ }
     }
 }
 async function collectKitFiles(root, output) {
@@ -215,11 +323,11 @@ function detectCapabilities(files, dependencies) {
  * capture groups never span a value. */
 const ENV_ACCESS_PATTERNS = [
     // JS/TS dot access and Deno (original rule).
-    /(?:process\.env\.|import\.meta\.env\.|Deno\.env\.get\(["'])([A-Z0-9_]{3,})/g,
+    /(?:process\.env\.|import\.meta\.env\.|Bun\.env\.|Deno\.env\.get\(\s*["'])([A-Z0-9_]{3,})/g,
     // JS/TS bracket access.
-    /(?:process\.env|import\.meta\.env)\[["']([A-Z0-9_]{3,})["']\]/g,
+    /(?:process\.env|import\.meta\.env|Bun\.env)\[\s*["']([A-Z0-9_]{3,})["']\s*\]/g,
     // Python: os.environ["X"], os.environ.get("X").
-    /\bos\.environ(?:\.get\(\s*|\[)["']([A-Z0-9_]{3,})["']/g,
+    /\bos\.environ(?:\.(?:get|setdefault)\(\s*|\[\s*)["']([A-Z0-9_]{3,})["']/g,
     // Go: os.Getenv("X"), os.LookupEnv("X").
     /\bos\.(?:Getenv|LookupEnv)\(\s*"([A-Z0-9_]{3,})"/g,
     // Ruby: ENV["X"], ENV.fetch("X").
@@ -254,10 +362,17 @@ function pushMatches(content, pattern, names) {
  * process.env.STRIPE_SECRET_KEY,` asked a builder for a key on 20 Sept 2026. */
 const COMMENT_LINE = /^\s*(?:\/\/|#|\*|\/\*|<!--)/;
 /** `const { SMTP_HOST, SMTP_PASS } = process.env` reads every destructured name. */
-const ENV_DESTRUCTURE = /\{([^}]*)\}\s*=\s*process\.env\b/g;
+const ENV_DESTRUCTURE = /\{\s*([^{}]*)\}\s*=\s*process\.env\b/g;
 /** `NAME=` at the start of a shell line declares a local variable; `$NAME`
  * later in that file is not an environment read. */
 const SHELL_LOCAL_ASSIGNMENT = /^\s*(?:export\s+)?([A-Z0-9_]{3,})=/gm;
+/**
+ * A name DECLARED by a container or compose instruction is not an environment
+ * read: `ENV NODE_ENV=production`, `ARG COMMIT_SHA=""`, `- WORKDIR=/app`,
+ * `WORKDIR: /app`. Without this, `${WORKDIR}` later in the same Dockerfile
+ * made WORKDIR a builder question (29 counted "reads" on one 2026-09-22 app).
+ */
+const MANIFEST_DECLARATION = /^\s*(?:-\s*)?(?:ENV|ARG)\s+([A-Z0-9_]{3,})\s*[=\s]|^\s*(?:-\s*)?([A-Z0-9_]{3,})\s*[:=]/gm;
 function uncommentedLines(content) {
     return content.split(/\r?\n/).filter(line => !COMMENT_LINE.test(line)).join("\n");
 }
@@ -276,6 +391,8 @@ function detectEnvNames(files) {
         }
         if (isShellContextFile(file.basename)) {
             const locals = new Set([...content.matchAll(SHELL_LOCAL_ASSIGNMENT)].map(match => match[1] ?? ""));
+            for (const match of content.matchAll(MANIFEST_DECLARATION))
+                locals.add(match[1] ?? match[2] ?? "");
             const expanded = [];
             pushMatches(content, SHELL_EXPANSION_PATTERN, expanded);
             names.push(...expanded.filter(name => !locals.has(name)));
@@ -294,7 +411,9 @@ function detectEnvNames(files) {
         }
         if (isEnvTemplateFile(file.basename)) {
             for (const line of (file.content ?? "").split(/\r?\n/)) {
-                const envMatch = /^([A-Z0-9_]{3,})=/.exec(line.trim());
+                // `export NAME=` is the shell-sourced template form; the evidence layer
+                // already accepted it, so detection has to as well or the two disagree.
+                const envMatch = /^(?:export\s+)?([A-Z0-9_]{3,})=/.exec(line.trim());
                 if (envMatch)
                     names.push(envMatch[1] ?? "");
             }
@@ -649,11 +768,17 @@ export async function scanWorkspace(root, options = {}) {
         throw new Error("ANALYZER_ROOT_INVALID: selected app root must be a real directory.");
     const unknowns = [];
     const files = [];
+    const filter = await loadGitIgnore(root);
     if (options.includePaths?.length)
-        await collectIncludedFiles(root, options.includePaths, files, unknowns);
+        await collectIncludedFiles(root, options.includePaths, files, filter);
     else
-        await collectFiles(root, root, files, unknowns);
+        await collectFiles(root, root, files, filter);
     const scopedFiles = files.sort((a, b) => a.path.localeCompare(b.path));
+    // Env names come from their own wider walk, except when the caller scoped
+    // the scan to explicit include paths — there the scope IS the answer.
+    const envScanFiles = [];
+    if (!options.includePaths?.length)
+        await collectEnvScanFiles(root, root, envScanFiles, filter);
     if (options.includePaths?.length && scopedFiles.length === 0)
         throw new Error("ANALYZER_INCLUDE_EMPTY: the declared include paths contain no eligible files.");
     const fingerprintInput = scopedFiles.map(file => `${file.path}:${file.size}:${file.content ? createHash("sha256").update(file.content).digest("hex") : "unread"}`).join("\n");
@@ -681,7 +806,7 @@ export async function scanWorkspace(root, options = {}) {
         capabilities: detectCapabilities(scopedFiles, dependencies),
         packageManagers,
         dependencyNames: dependencies,
-        environmentVariableNames: detectEnvNames(scopedFiles),
+        environmentVariableNames: detectEnvNames(envScanFiles.length ? envScanFiles : scopedFiles),
         testCommands: detectTestCommands(scripts),
         analysis: {
             analyzerVersion: ANALYZER_VERSION,

package/dist/src/gitignore.js

@@ -0,0 +1,81 @@
+export function parseGitIgnore(content) {
+    const rules = [];
+    for (const raw of content.split(/\r?\n/)) {
+        let line = raw.replace(/\s+$/, "");
+        if (!line || line.startsWith("#"))
+            continue;
+        let negated = false;
+        if (line.startsWith("!")) {
+            negated = true;
+            line = line.slice(1);
+        }
+        else if (line.startsWith("\\!") || line.startsWith("\\#"))
+            line = line.slice(1);
+        let directoryOnly = false;
+        if (line.endsWith("/")) {
+            directoryOnly = true;
+            line = line.slice(0, -1);
+        }
+        if (!line)
+            continue;
+        let anchored = line.startsWith("/");
+        if (anchored)
+            line = line.slice(1);
+        if (line.includes("/"))
+            anchored = true;
+        const regex = new RegExp(`^${anchored ? "" : "(?:.*/)?"}${globToRegex(line)}(?:/.*)?$`);
+        rules.push({ regex, negated, directoryOnly });
+    }
+    return {
+        ignores(path, isDirectory) {
+            const normalized = path.replace(/^\/+|\/+$/g, "");
+            if (!normalized)
+                return false;
+            let ignored = false;
+            for (const rule of rules) {
+                if (rule.directoryOnly && !isDirectory && !parentMatches(rule.regex, normalized))
+                    continue;
+                if (rule.regex.test(normalized))
+                    ignored = !rule.negated;
+            }
+            return ignored;
+        }
+    };
+}
+/** A directory-only pattern still ignores a file beneath a matching directory. */
+function parentMatches(regex, path) {
+    const parts = path.split("/");
+    for (let depth = 1; depth < parts.length; depth += 1)
+        if (regex.test(parts.slice(0, depth).join("/")))
+            return true;
+    return false;
+}
+function globToRegex(glob) {
+    let out = "";
+    for (let index = 0; index < glob.length; index += 1) {
+        const char = glob[index];
+        if (char === "*") {
+            if (glob[index + 1] === "*") {
+                index += 1;
+                if (glob[index + 1] === "/") {
+                    index += 1;
+                    out += "(?:.*/)?";
+                }
+                else
+                    out += ".*";
+            }
+            else
+                out += "[^/]*";
+        }
+        else if (char === "?")
+            out += "[^/]";
+        else if (char === "\\" && index + 1 < glob.length) {
+            index += 1;
+            out += escape(glob[index]);
+        }
+        else
+            out += escape(char);
+    }
+    return out;
+}
+function escape(char) { return /[.*+?^${}()|[\]\\/]/.test(char) ? `\\${char}` : char; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isomorph.ai/cli",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Isomorph development kit CLI",
   "type": "module",
   "bin": {
@@ -18,6 +18,7 @@
     "dist/src/analyzer.js",
     "dist/src/contracts.js",
     "dist/src/digest.js",
+    "dist/src/gitignore.js",
     "dist/src/secret-paths.js",
     "dist/src/source-digest.js",
     "dist/src/source-intake.js",