modelrig 0.0.1 → 0.2.0

package/dist/init/finder.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Provider call-site finder — `modelrig init` v0 (spec WS2).
+ *
+ * AST-lite on purpose: a balanced-brace reader over the call's options
+ * object, not a TypeScript parser. The job is to find call sites and read
+ * the handful of literals that matter (model, system prompt, schema hint,
+ * generation params) well enough to DRAFT a route a human will review. It is
+ * allowed to be unsure — every uncertainty is recorded as a `note` on the
+ * site rather than guessed into the output, because a confident wrong draft
+ * is worse than an honest incomplete one.
+ *
+ * Generic by construction: everything provider-specific lives in
+ * signatures.ts. No repo, framework, or company is special-cased.
+ */
+export interface CallSiteParams {
+    readonly temperature?: number;
+    readonly topP?: number;
+    readonly maxTokens?: number;
+    readonly timeoutMs?: number;
+}
+export interface CallSite {
+    readonly file: string;
+    /** 1-indexed line of the call expression. */
+    readonly line: number;
+    readonly provider: string;
+    /** Model id when it was a literal; null when it came from a variable. */
+    readonly model: string | null;
+    /** The identifier the model came from, when it wasn't a literal. */
+    readonly modelExpression: string | null;
+    /** Literal system prompt when inline; null when referenced or absent. */
+    readonly systemPrompt: string | null;
+    /** The caller asked for structured output (schema/JSON mode present). */
+    readonly wantsStructuredOutput: boolean;
+    /** How the schema was expressed, when we could tell: zod | json-schema | json-mode. */
+    readonly schemaHint: string | null;
+    readonly params: CallSiteParams;
+    /** How the site was recognized — SDK call shape, or the API host. */
+    readonly matchedBy: "sdk" | "host";
+    /** Honest uncertainties for the human reviewing the draft. */
+    readonly notes: readonly string[];
+}
+export interface FinderOptions {
+    /** Skip these directory names anywhere in the tree. */
+    readonly skipDirs?: readonly string[];
+    readonly extensions?: readonly string[];
+    /** Include test files. Off by default: a mock is not a call site. */
+    readonly includeTests?: boolean;
+    readonly maxFileBytes?: number;
+    /**
+     * Narrow the scan to these paths/globs (F-4). Matched against each file's
+     * repo-relative POSIX path; a file matching NONE is not read at all. A
+     * pattern with no glob metachar (`*`/`?`/`[`) is a directory-prefix match
+     * (`src/pipeline` ⇒ everything under it); otherwise it is a glob where `*`
+     * stays within a path segment and `**` spans them. Empty/undefined = no
+     * narrowing (scan everything), so the default behaviour is unchanged.
+     */
+    readonly scope?: readonly string[];
+}
+/** Compile one scope pattern into a matcher over repo-relative POSIX paths.
+ * Bare paths (no glob metachar) match the file itself or anything beneath it,
+ * so `--scope src/pipeline` onboards one pipeline directory without ceremony. */
+export declare function compileScope(pattern: string): (relPath: string) => boolean;
+/** True when `relPath` matches ANY scope (or no scope is set). */
+export declare function matchesScope(relPath: string, scope: readonly string[] | undefined): boolean;
+export declare const DEFAULT_SKIP_DIRS: readonly string[];
+export interface FileSystemLike {
+    readdirSync(path: string, options: {
+        withFileTypes: true;
+    }): Array<{
+        name: string;
+        isDirectory(): boolean;
+        isFile(): boolean;
+    }>;
+    readFileSync(path: string, encoding: "utf8"): string;
+    statSync(path: string): {
+        size: number;
+    };
+}
+/** Read the balanced `{...}` object starting at or after `from`. Returns null
+ * when the call has no object literal (e.g. a spread or a variable). */
+export declare function readObjectLiteral(source: string, from: number): string | null;
+/** Find provider call sites in one file's text. Exported for fixtures. */
+export declare function findCallSitesInText(file: string, fileText: string): CallSite[];
+export interface ScanResult {
+    readonly sites: readonly CallSite[];
+    readonly filesScanned: number;
+    /** Files skipped for size — reported, never silently dropped. */
+    readonly filesSkipped: readonly string[];
+}
+export declare function scanRepoForCallSites(root: string, fs: FileSystemLike, path: {
+    join: (...parts: string[]) => string;
+    relative: (from: string, to: string) => string;
+}, options?: FinderOptions): ScanResult;
+//# sourceMappingURL=finder.d.ts.map

package/dist/init/finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finder.d.ts","sourceRoot":"","sources":["../../src/init/finder.ts"],"names":[],"mappings":"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"}

package/dist/init/finder.js

@@ -0,0 +1,343 @@
+"use strict";
+/**
+ * Provider call-site finder — `modelrig init` v0 (spec WS2).
+ *
+ * AST-lite on purpose: a balanced-brace reader over the call's options
+ * object, not a TypeScript parser. The job is to find call sites and read
+ * the handful of literals that matter (model, system prompt, schema hint,
+ * generation params) well enough to DRAFT a route a human will review. It is
+ * allowed to be unsure — every uncertainty is recorded as a `note` on the
+ * site rather than guessed into the output, because a confident wrong draft
+ * is worse than an honest incomplete one.
+ *
+ * Generic by construction: everything provider-specific lives in
+ * signatures.ts. No repo, framework, or company is special-cased.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SKIP_DIRS = void 0;
+exports.compileScope = compileScope;
+exports.matchesScope = matchesScope;
+exports.readObjectLiteral = readObjectLiteral;
+exports.findCallSitesInText = findCallSitesInText;
+exports.scanRepoForCallSites = scanRepoForCallSites;
+const signatures_1 = require("./signatures");
+/** Compile one scope pattern into a matcher over repo-relative POSIX paths.
+ * Bare paths (no glob metachar) match the file itself or anything beneath it,
+ * so `--scope src/pipeline` onboards one pipeline directory without ceremony. */
+function compileScope(pattern) {
+    const trimmed = pattern.replace(/\/+$/, "");
+    if (!/[*?[\]]/.test(trimmed)) {
+        return (relPath) => relPath === trimmed || relPath.startsWith(`${trimmed}/`);
+    }
+    // Glob → RegExp. `**` spans path segments; a lone `*` stops at one. Every
+    // other regex metacharacter is escaped so a literal `.` stays literal.
+    let re = "";
+    for (let i = 0; i < trimmed.length; i += 1) {
+        const ch = trimmed[i];
+        if (ch === "*") {
+            if (trimmed[i + 1] === "*") {
+                re += ".*";
+                i += 1;
+            }
+            else {
+                re += "[^/]*";
+            }
+        }
+        else if (ch === "?") {
+            re += "[^/]";
+        }
+        else if ("\\^$.|+()[]{}".includes(ch)) {
+            re += `\\${ch}`;
+        }
+        else {
+            re += ch;
+        }
+    }
+    const compiled = new RegExp(`^${re}$`);
+    return (relPath) => compiled.test(relPath);
+}
+/** True when `relPath` matches ANY scope (or no scope is set). */
+function matchesScope(relPath, scope) {
+    if (scope === undefined || scope.length === 0)
+        return true;
+    return scope.some((pattern) => compileScope(pattern)(relPath));
+}
+exports.DEFAULT_SKIP_DIRS = [
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".git",
+    "coverage",
+    "vendor",
+    ".turbo",
+];
+const DEFAULT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+const DEFAULT_MAX_FILE_BYTES = 1000000;
+/** Read the balanced `{...}` object starting at or after `from`. Returns null
+ * when the call has no object literal (e.g. a spread or a variable). */
+function readObjectLiteral(source, from) {
+    const open = source.indexOf("{", from);
+    if (open === -1)
+        return null;
+    // Anything but whitespace between the paren and the brace means the first
+    // argument is not an inline object — don't misread a later one.
+    const between = source.slice(from, open);
+    if (/[^\s(]/.test(between))
+        return null;
+    let depth = 0;
+    let inString = null;
+    let escaped = false;
+    for (let i = open; i < source.length; i += 1) {
+        const char = source[i];
+        if (inString !== null) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === inString)
+                inString = null;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            inString = char;
+            continue;
+        }
+        if (char === "{")
+            depth += 1;
+        else if (char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return source.slice(open, i + 1);
+        }
+    }
+    return null; // unbalanced — treat as unreadable rather than guessing
+}
+/** Read `key: "literal"` at any nesting depth of the options object. */
+function readStringOption(objectText, key) {
+    const pattern = new RegExp(`\\b${key}\\s*:\\s*(['"\`])((?:\\\\.|(?!\\1).)*)\\1`, "s");
+    const match = objectText.match(pattern);
+    return match === null ? null : match[2].replace(/\\n/g, "\n").replace(/\\(['"`])/g, "$1");
+}
+function readNumberOption(objectText, key) {
+    const match = objectText.match(new RegExp(`\\b${key}\\s*:\\s*(-?\\d+(?:\\.\\d+)?)`));
+    return match === null ? null : Number(match[1]);
+}
+/** The identifier a non-literal option refers to — reported, never resolved. */
+function readIdentifierOption(objectText, key) {
+    const match = objectText.match(new RegExp(`\\b${key}\\s*:\\s*([A-Za-z_$][\\w$.]*)`));
+    return match === null ? null : match[1];
+}
+function hasKey(objectText, key) {
+    return new RegExp(`\\b${key}\\s*:`).test(objectText);
+}
+function lineOf(source, index) {
+    let line = 1;
+    for (let i = 0; i < index && i < source.length; i += 1) {
+        if (source[i] === "\n")
+            line += 1;
+    }
+    return line;
+}
+function detectSchemaHint(objectText, fileText, signature) {
+    for (const key of signature.schemaKeys) {
+        if (!hasKey(objectText, key))
+            continue;
+        const identifier = readIdentifierOption(objectText, key);
+        if (identifier !== null && /zod|Schema$/i.test(identifier))
+            return "zod";
+        if (key === "responseMimeType") {
+            return readStringOption(objectText, key) === "application/json" ? "json-mode" : null;
+        }
+        if (/json_schema|responseSchema|responseJsonSchema|output_schema/.test(key))
+            return "json-schema";
+        if (readStringOption(objectText, key) === "json_object")
+            return "json-mode";
+        if (/json_object/.test(objectText))
+            return "json-mode";
+        return "json-schema";
+    }
+    // A zod import plus a parse near the call is the common untyped-SDK shape.
+    if (/from\s+["']zod["']/.test(fileText) && /\bz\.object\s*\(/.test(fileText))
+        return "zod";
+    return null;
+}
+function extractParams(objectText) {
+    const params = {};
+    for (const [key, normalized] of Object.entries(signatures_1.PARAM_KEYS)) {
+        const value = readNumberOption(objectText, key);
+        if (value !== null && params[normalized] === undefined)
+            params[normalized] = value;
+    }
+    return params;
+}
+function buildSite(args) {
+    const { file, fileText, index, signature, matchedBy } = args;
+    const objectText = readObjectLiteral(fileText, index) ?? "";
+    const notes = [];
+    let model = null;
+    let modelExpression = null;
+    const modelKeys = signature.modelKeys.length > 0 ? signature.modelKeys : signatures_1.ALL_MODEL_KEYS;
+    for (const key of modelKeys) {
+        model = readStringOption(objectText, key);
+        if (model !== null)
+            break;
+        modelExpression = modelExpression ?? readIdentifierOption(objectText, key);
+    }
+    if (objectText === "") {
+        notes.push("The call's options were not an inline object, so nothing could be read from it — " +
+            "fill in the model and prompt by hand.");
+    }
+    else if (model === null) {
+        notes.push(modelExpression === null
+            ? "No model id found at this call site — name the model in the draft before running it."
+            : `The model comes from \`${modelExpression}\`, not a literal — set the candidate by hand ` +
+                "(and check whether it varies at runtime, which is exactly what a route replaces).");
+    }
+    let systemPrompt = null;
+    for (const key of signature.systemKeys) {
+        systemPrompt = readStringOption(objectText, key);
+        if (systemPrompt !== null)
+            break;
+    }
+    // OpenAI/Anthropic-style: the system turn lives inside `messages`.
+    if (systemPrompt === null && /role\s*:\s*['"`]system['"`]/.test(objectText)) {
+        const match = objectText.match(/role\s*:\s*['"`]system['"`]\s*,\s*content\s*:\s*(['"`])((?:\\.|(?!\1).)*)\1/s);
+        if (match !== null)
+            systemPrompt = match[2];
+    }
+    if (systemPrompt === null && objectText !== "") {
+        notes.push("No inline system prompt found — it is probably built in a variable. Paste it into the " +
+            "drafted prompt file.");
+    }
+    const schemaHint = detectSchemaHint(objectText, fileText, signature);
+    const wantsStructuredOutput = schemaHint !== null || signature.schemaKeys.some((k) => hasKey(objectText, k));
+    return {
+        file,
+        line: lineOf(fileText, index),
+        provider: signature.provider,
+        model,
+        modelExpression: model === null ? modelExpression : null,
+        systemPrompt,
+        wantsStructuredOutput,
+        schemaHint,
+        params: extractParams(objectText),
+        matchedBy,
+        notes,
+    };
+}
+/** Find provider call sites in one file's text. Exported for fixtures. */
+function findCallSitesInText(file, fileText) {
+    const sites = [];
+    const seen = new Set();
+    for (const signature of signatures_1.PROVIDER_SIGNATURES) {
+        const sdkPresent = signature.packages.length === 0 ||
+            signature.packages.some((pkg) => 
+            // Static `from "pkg"`, CommonJS `require("pkg")`, AND dynamic
+            // `await import("pkg")` — lazy SDK loading is common in server code
+            // and missing it silently hides real call sites.
+            new RegExp(`(from|require\\(|import\\()\\s*["']${pkg.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")}["']`).test(fileText));
+        if (sdkPresent) {
+            for (const pattern of signature.callPatterns) {
+                const regex = (0, signatures_1.freshPattern)(pattern);
+                let match = regex.exec(fileText);
+                while (match !== null) {
+                    const index = match.index + match[0].length - 1;
+                    if (!seen.has(index)) {
+                        seen.add(index);
+                        sites.push(buildSite({ file, fileText, index, signature, matchedBy: "sdk" }));
+                    }
+                    match = regex.exec(fileText);
+                }
+            }
+        }
+        // Host fallback: a raw fetch() to a provider API is still a call site.
+        // But a bare `const BASE_URL = "https://api.deepseek.com"` is NOT one —
+        // SDK-configured providers name their host in a constant, and reporting
+        // that as a call site produces a route nobody asked for. Require the
+        // mention to sit inside something request-shaped.
+        for (const host of signature.hosts) {
+            const hostRegex = new RegExp(host.replace(/\./g, "\\."), "g");
+            let match = hostRegex.exec(fileText);
+            while (match !== null) {
+                const before = fileText.slice(Math.max(0, match.index - 200), match.index);
+                const after = fileText.slice(match.index, match.index + 600);
+                const isRequest = /\b(fetch|request|axios|got|post)\s*\(/.test(before) && /\bbody\s*:/.test(after);
+                if (!isRequest) {
+                    match = hostRegex.exec(fileText);
+                    continue;
+                }
+                // A raw fetch puts the request in `body:`, usually wrapped in
+                // JSON.stringify(...). Aim the object reader at the payload itself
+                // rather than at the `body` key, or the wrapper hides it.
+                const bodyIndex = fileText.indexOf("body", match.index);
+                let index = bodyIndex === -1 ? match.index : bodyIndex + 4;
+                if (bodyIndex !== -1) {
+                    const window = fileText.slice(bodyIndex, bodyIndex + 60);
+                    const wrapper = window.indexOf("JSON.stringify(");
+                    if (wrapper !== -1)
+                        index = bodyIndex + wrapper + "JSON.stringify(".length;
+                    else
+                        index = fileText.indexOf(":", bodyIndex) + 1;
+                }
+                const near = [...seen].some((s) => Math.abs(s - index) < 400);
+                if (!near) {
+                    seen.add(index);
+                    sites.push(buildSite({ file, fileText, index, signature, matchedBy: "host" }));
+                }
+                match = hostRegex.exec(fileText);
+            }
+        }
+    }
+    return sites.sort((a, b) => a.line - b.line);
+}
+function scanRepoForCallSites(root, fs, path, options = {}) {
+    const skipDirs = new Set(options.skipDirs ?? exports.DEFAULT_SKIP_DIRS);
+    const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+    const maxBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    const sites = [];
+    const skipped = [];
+    let filesScanned = 0;
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // unreadable directory is not a reason to abort the scan
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (skipDirs.has(entry.name))
+                    continue;
+                walk(full);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!extensions.some((ext) => entry.name.endsWith(ext)))
+                continue;
+            const isTest = /\.(test|spec)\.[jt]sx?$/.test(entry.name) || full.includes("__tests__") || full.includes("__mocks__");
+            if (isTest && options.includeTests !== true)
+                continue;
+            // F-4: a file outside every --scope is never read (not counted scanned).
+            if (!matchesScope(path.relative(root, full), options.scope))
+                continue;
+            try {
+                if (fs.statSync(full).size > maxBytes) {
+                    skipped.push(path.relative(root, full));
+                    continue;
+                }
+                const text = fs.readFileSync(full, "utf8");
+                filesScanned += 1;
+                sites.push(...findCallSitesInText(path.relative(root, full), text));
+            }
+            catch {
+                skipped.push(path.relative(root, full));
+            }
+        }
+    };
+    walk(root);
+    return { sites, filesScanned, filesSkipped: skipped };
+}

package/dist/init/init-cli.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `modelrig init` command runner — lives here (not cli.ts) for the LOC cap
+ * (P1), beside the scaffold it drives (same split as observe-cli.ts and
+ * verify/cli-run.ts). Scans a repo for provider call sites and drafts a route
+ * bundle per site plus a MIGRATION.md map. It writes ONLY under
+ * <routes-dir>/drafts/; the target's source is never edited.
+ */
+import type { ObserveFlags } from "./observe-cli";
+export declare function cmdInit(flags: ObserveFlags): number;
+//# sourceMappingURL=init-cli.d.ts.map

package/dist/init/init-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-cli.d.ts","sourceRoot":"","sources":["../../src/init/init-cli.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAwFnD"}

package/dist/init/init-cli.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * `modelrig init` command runner — lives here (not cli.ts) for the LOC cap
+ * (P1), beside the scaffold it drives (same split as observe-cli.ts and
+ * verify/cli-run.ts). Scans a repo for provider call sites and drafts a route
+ * bundle per site plus a MIGRATION.md map. It writes ONLY under
+ * <routes-dir>/drafts/; the target's source is never edited.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdInit = cmdInit;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("../config");
+const rows_1 = require("../registry/rows");
+const observe_cli_1 = require("./observe-cli");
+const run_1 = require("./run");
+function cmdInit(flags) {
+    // `init --observe` is the observe-first (T0/T1) alias for `modelrig observe`.
+    if (flags.bare.has("observe"))
+        return (0, observe_cli_1.cmdObserve)(flags);
+    const root = (0, node_path_1.resolve)(flags.positional[0] ?? ".");
+    const config = (0, config_1.loadConfigFromEnv)();
+    const draftsDir = flags.named.get("out") ?? (0, node_path_1.join)(config.routesDir, "drafts");
+    const scope = (0, observe_cli_1.scopeFrom)(flags);
+    // Registry rows seed the challenger candidates. A missing/unbuilt registry
+    // is not fatal — drafts then carry the incumbent alone, and say so.
+    let registryRows = [];
+    try {
+        registryRows = (0, rows_1.loadRegistryRows)(config.registryPath);
+    }
+    catch {
+        registryRows = [];
+    }
+    const result = (0, run_1.runInit)({
+        root,
+        draftsDir,
+        fs: { readdirSync: node_fs_1.readdirSync, readFileSync: node_fs_1.readFileSync, statSync: node_fs_1.statSync, existsSync: node_fs_1.existsSync, mkdirSync: node_fs_1.mkdirSync, writeFileSync: node_fs_1.writeFileSync },
+        path: { join: node_path_1.join, relative: node_path_1.relative, dirname: node_path_1.dirname, basename: node_path_1.basename },
+    }, {
+        registryRows,
+        ...(flags.bare.has("dry-run") ? { dryRun: true } : {}),
+        ...(flags.bare.has("include-tests") ? { includeTests: true } : {}),
+        ...(scope !== undefined ? { scope } : {}),
+    });
+    if (flags.bare.has("json")) {
+        console.log(JSON.stringify({
+            sitesFound: result.sitesFound,
+            filesScanned: result.filesScanned,
+            filesSkipped: result.filesSkipped,
+            routes: result.drafts.map((d) => ({
+                route: d.route,
+                file: d.site.file,
+                line: d.site.line,
+                provider: d.site.provider,
+                model: d.site.model,
+                notes: d.site.notes,
+            })),
+            written: result.written,
+            skipped: result.skipped,
+        }, null, 2));
+        return 0;
+    }
+    console.log(`modelrig init — scanned ${result.filesScanned} file(s) under ${root}` +
+        (scope !== undefined ? ` (scoped to ${scope.join(", ")})` : "") +
+        `\nfound ${result.sitesFound} provider call site(s)`);
+    if (result.sitesFound === 0) {
+        console.log("\nNothing to draft. If you know there are model calls here, they may sit behind a helper\n" +
+            "that hides the SDK — point init at the file that actually calls the provider.");
+        return 0;
+    }
+    for (const draft of result.drafts) {
+        console.log(`  ${draft.site.file}:${draft.site.line} (${draft.site.provider}` +
+            `${draft.site.model !== null ? ` ${draft.site.model}` : ""}) → ${draft.route}`);
+    }
+    if (result.filesSkipped.length > 0) {
+        console.log(`\n${result.filesSkipped.length} file(s) skipped (too large or unreadable).`);
+    }
+    if (flags.bare.has("dry-run")) {
+        console.log("\n--dry-run: nothing written.");
+        return 0;
+    }
+    console.log(`\nwrote ${result.written.length} file(s) to ${draftsDir}` +
+        (result.skipped.length > 0 ? ` (${result.skipped.length} left alone — already there)` : "") +
+        `\nread ${(0, node_path_1.join)(draftsDir, "MIGRATION.md")} next. Your source was not touched.`);
+    return 0;
+}

package/dist/init/observe-cli.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `modelrig observe` command runner — lives here (not cli.ts) for the LOC cap
+ * (P1), beside the scaffold it drives (same split as verify/cli-run.ts and
+ * bakeoff/report.ts). Closes onboarding-test run-1's headline gap (F-1: the
+ * only observe on-ramp was a hand-wired SDK seam with no CLI). Like `init`, it
+ * NEVER edits the target's source — it writes only under its out dir.
+ */
+/** Structural view of the CLI's parsed flags — declared here so this module
+ * never imports cli.ts (which imports us), keeping the dependency one-way. */
+export interface ObserveFlags {
+    readonly positional: readonly string[];
+    readonly named: ReadonlyMap<string, string>;
+    readonly bare: ReadonlySet<string>;
+}
+/** `--scope a,b` → the finder's scope narrowing (F-4). Comma-separated globs
+ * or path prefixes; absent = scan everything. Shared with `modelrig init`. */
+export declare function scopeFrom(flags: ObserveFlags): readonly string[] | undefined;
+export declare function cmdObserve(flags: ObserveFlags): number;
+//# sourceMappingURL=observe-cli.d.ts.map

package/dist/init/observe-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe-cli.d.ts","sourceRoot":"","sources":["../../src/init/observe-cli.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH;8EAC8E;AAC9E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACpC;AAED;8EAC8E;AAC9E,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAK5E;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAgEtD"}

package/dist/init/observe-cli.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * `modelrig observe` command runner — lives here (not cli.ts) for the LOC cap
+ * (P1), beside the scaffold it drives (same split as verify/cli-run.ts and
+ * bakeoff/report.ts). Closes onboarding-test run-1's headline gap (F-1: the
+ * only observe on-ramp was a hand-wired SDK seam with no CLI). Like `init`, it
+ * NEVER edits the target's source — it writes only under its out dir.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopeFrom = scopeFrom;
+exports.cmdObserve = cmdObserve;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("../config");
+const observe_1 = require("./observe");
+/** `--scope a,b` → the finder's scope narrowing (F-4). Comma-separated globs
+ * or path prefixes; absent = scan everything. Shared with `modelrig init`. */
+function scopeFrom(flags) {
+    const raw = flags.named.get("scope");
+    if (raw === undefined)
+        return undefined;
+    const scope = raw.split(",").map((s) => s.trim()).filter((s) => s !== "");
+    return scope.length > 0 ? scope : undefined;
+}
+function cmdObserve(flags) {
+    const root = (0, node_path_1.resolve)(flags.positional[0] ?? ".");
+    const config = (0, config_1.loadConfigFromEnv)();
+    // Sibling of the routes dir: <repo>/modelrig/observe by default.
+    const outDir = flags.named.get("out") ?? (0, node_path_1.join)((0, node_path_1.dirname)(config.routesDir), "observe");
+    const scope = scopeFrom(flags);
+    const result = (0, observe_1.runObserve)({
+        root,
+        outDir,
+        fs: { readdirSync: node_fs_1.readdirSync, readFileSync: node_fs_1.readFileSync, statSync: node_fs_1.statSync, existsSync: node_fs_1.existsSync, mkdirSync: node_fs_1.mkdirSync, writeFileSync: node_fs_1.writeFileSync },
+        path: { join: node_path_1.join, relative: node_path_1.relative, dirname: node_path_1.dirname, basename: node_path_1.basename },
+    }, {
+        ...(flags.bare.has("dry-run") ? { dryRun: true } : {}),
+        ...(flags.bare.has("include-tests") ? { includeTests: true } : {}),
+        ...(scope !== undefined ? { scope } : {}),
+    });
+    if (flags.bare.has("json")) {
+        console.log(JSON.stringify({
+            sitesFound: result.sitesFound,
+            filesScanned: result.filesScanned,
+            filesSkipped: result.filesSkipped,
+            steps: result.plans.map((p) => ({
+                stepKey: p.stepKey,
+                file: p.site.file,
+                line: p.site.line,
+                provider: p.site.provider,
+                model: p.site.model,
+            })),
+            written: result.written,
+            skipped: result.skipped,
+        }, null, 2));
+        return 0;
+    }
+    console.log(`modelrig observe — scanned ${result.filesScanned} file(s) under ${root}` +
+        (scope !== undefined ? ` (scoped to ${scope.join(", ")})` : "") +
+        `\nfound ${result.sitesFound} model call site(s) → ${result.sitesFound} proposed step(s)`);
+    for (const plan of result.plans) {
+        console.log(`  ${plan.site.file}:${plan.site.line} → step "${plan.stepKey}"`);
+    }
+    if (flags.bare.has("dry-run")) {
+        console.log("\n--dry-run: nothing written.");
+        return 0;
+    }
+    console.log(`\nwrote ${result.written.length} file(s) to ${outDir}` +
+        (result.skipped.length > 0 ? ` (${result.skipped.length} left alone — already there)` : "") +
+        `\nread ${(0, node_path_1.join)(outDir, "OBSERVE.md")} next — apply the wiring diffs one step at a time.` +
+        "\nObserve changes no behaviour; with MODELRIG_ARTIFACTS off your pipeline is byte-for-byte the same.");
+    return 0;
+}