modelrig 0.0.1 → 0.1.0

package/dist/init/finder.js

@@ -0,0 +1,297 @@
+"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.readObjectLiteral = readObjectLiteral;
+exports.findCallSitesInText = findCallSitesInText;
+exports.scanRepoForCallSites = scanRepoForCallSites;
+const signatures_1 = require("./signatures");
+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;
+            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/run.d.ts

@@ -0,0 +1,99 @@
+/**
+ * `modelrig init` v0 — spec WS2.
+ *
+ * Finds provider call sites in a repo, drafts a route bundle per site, and
+ * writes a MIGRATION.md mapping call site → route → the `rig.run` line that
+ * would replace it.
+ *
+ * THE HARD RULE, restated because it is the whole design: init NEVER edits
+ * the target's source. It writes under `modelrig/routes/drafts/` and nothing
+ * else. The diff is the human's to apply — spec §4 puts writing-to-source
+ * permanently out of scope for this phase, and the drafts-only property is
+ * tested, not just documented.
+ */
+import type { CallSite, FileSystemLike, FinderOptions } from "./finder";
+import type { ModelSelectRow, CapabilityPredicate } from "../registry/select";
+import type { RouteDraft } from "../routes/draft";
+/**
+ * The cost opportunity at a call site — SHOWN, never taken.
+ *
+ * A migration draft routes to the incumbent so the first run reproduces
+ * today's behavior (see draft.ts on why `prefer` is empty). That is a
+ * sequencing decision, not a decision to ignore cost: the saving is the
+ * whole point of the product, so the migration map names it and hands over
+ * the one command that would prove it.
+ *
+ * The number is INDICATIVE. It comes from probe runs on a generic schema
+ * task, not from the caller's traffic — which is exactly why the honest move
+ * is to show it next to a bake-off command rather than act on it.
+ */
+export interface CostOutlook {
+    readonly incumbentEffectiveUsdPer1k: number | null;
+    readonly bestChallenger: {
+        readonly model: string;
+        readonly effectiveUsdPer1k: number;
+    } | null;
+    /** Indicative only; null when the incumbent is unprobed. */
+    readonly indicativeSavingsPct: number | null;
+    /** Why the number is, or is not, available. */
+    readonly note: string;
+}
+export interface InitDraft {
+    readonly route: string;
+    readonly site: CallSite;
+    readonly draft: RouteDraft;
+    readonly candidateReasoning: readonly string[];
+    /** The rig.run(...) call that would replace this site. */
+    readonly replacement: string;
+    readonly costOutlook: CostOutlook;
+}
+export interface InitResult {
+    readonly drafts: readonly InitDraft[];
+    readonly sitesFound: number;
+    readonly filesScanned: number;
+    readonly filesSkipped: readonly string[];
+    readonly written: readonly string[];
+    readonly skipped: readonly string[];
+    readonly migrationMarkdown: string;
+}
+export interface InitOptions extends FinderOptions {
+    /** Registry rows for candidate seeding; empty = incumbent-only drafts. */
+    readonly registryRows?: readonly ModelSelectRow[];
+    readonly challengerCount?: number;
+    /** Plan without writing (`--dry-run`). */
+    readonly dryRun?: boolean;
+}
+export interface InitDeps {
+    readonly root: string;
+    readonly draftsDir: string;
+    readonly fs: FileSystemLike & {
+        existsSync: (p: string) => boolean;
+        mkdirSync: (p: string, o: {
+            recursive: boolean;
+        }) => void;
+        writeFileSync: (p: string, c: string, e: "utf8") => void;
+    };
+    readonly path: {
+        join: (...parts: string[]) => string;
+        relative: (from: string, to: string) => string;
+        dirname: (p: string) => string;
+        basename: (p: string, ext?: string) => string;
+    };
+}
+/** Route name from a call site: `<file stem>.<line>` namespaced by its
+ * directory, e.g. "services.asset_classifier_42". Deterministic so a second
+ * run produces the same names and therefore skips the same drafts. */
+export declare function routeNameFor(site: CallSite, basename: (p: string, ext?: string) => string): string;
+/** What the site's structured-output usage implies about capability needs.
+ * Conservative: a json_schema request implies native enforcement is wanted;
+ * bare JSON mode only implies conformance. */
+export declare function capabilitiesFor(site: CallSite): CapabilityPredicate[];
+/** Price the incumbent against the cheapest probed challenger, honestly. */
+export declare function buildCostOutlook(incumbentKey: string | null, challengerKeys: readonly string[], rows: readonly ModelSelectRow[]): CostOutlook;
+export declare function buildMigrationMarkdown(drafts: readonly InitDraft[], result: {
+    sitesFound: number;
+    filesScanned: number;
+    filesSkipped: readonly string[];
+}): string;
+export declare function runInit(deps: InitDeps, options?: InitOptions): InitResult;
+//# sourceMappingURL=run.d.ts.map

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

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