@bondedhq/runner 0.0.0-stage → 0.1.0

package/dist/init/detect.d.ts

@@ -0,0 +1,34 @@
+/** The agent frameworks `init` knows. */
+export declare const FRAMEWORKS: readonly ["eliza", "agentkit", "langchain", "ai-sdk", "mcp", "python", "unknown"];
+export type Framework = (typeof FRAMEWORKS)[number];
+export declare const FRAMEWORK_NAMES: Record<Framework, string>;
+/** Web frameworks `init --url` can add an Agent URL route to. */
+export type WebFramework = "next-app" | "next-pages" | "express" | "hono" | "node-http";
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+/** What `init` found in the agent's folder. Paths are relative to `root`, with `/`. */
+export interface Project {
+    root: string;
+    framework: Framework;
+    /** Why it decided on the framework, in words. */
+    evidence: string;
+    packageManager: PackageManager;
+    /** TypeScript (a tsconfig.json or a typescript dependency). */
+    typescript: boolean;
+    /** package.json `"type": "module"`: plain .js files are ES modules. */
+    esm: boolean;
+    /** How relative imports are written in TypeScript: with `.js` (NodeNext) or without. */
+    importExtension: "" | ".js";
+    /** Where source files live: `src` when there is one, else the root. */
+    sourceDir: string;
+    /** Source files (TS/JS), skipping node_modules, build output and tests. */
+    sources: string[];
+    dependencies: Record<string, string>;
+    scripts: Record<string, string>;
+    web: WebFramework;
+    /** Next.js App Router folder (`app` or `src/app`), when there is one. */
+    nextAppDir?: string;
+    nextMajor?: number;
+    hasSdk: boolean;
+}
+export declare function detectProject(root: string, override?: Framework): Project;
+//# sourceMappingURL=detect.d.ts.map

package/dist/init/detect.js

@@ -0,0 +1,184 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+/** The agent frameworks `init` knows. */
+export const FRAMEWORKS = [
+    "eliza",
+    "agentkit",
+    "langchain",
+    "ai-sdk",
+    "mcp",
+    "python",
+    "unknown",
+];
+export const FRAMEWORK_NAMES = {
+    eliza: "ElizaOS",
+    agentkit: "Coinbase AgentKit",
+    langchain: "LangChain / LangGraph",
+    "ai-sdk": "Vercel AI SDK",
+    mcp: "an MCP client",
+    python: "Python",
+    unknown: "an unrecognised framework",
+};
+const SKIP = new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".git",
+    ".turbo",
+    "coverage",
+    "test",
+    "tests",
+    "__tests__",
+]);
+const SOURCE = /\.(ts|tsx|mts|js|mjs|jsx)$/;
+const MAX_SOURCES = 400;
+export function detectProject(root, override) {
+    const pkgPath = join(root, "package.json");
+    const pkg = existsSync(pkgPath)
+        ? JSON.parse(readFileSync(pkgPath, "utf8"))
+        : undefined;
+    const dependencies = { ...pkg?.devDependencies, ...pkg?.dependencies };
+    const has = (name) => name in dependencies;
+    const tsconfig = readTsconfig(root);
+    const typescript = tsconfig !== undefined || has("typescript");
+    const sourceDir = existsSync(join(root, "src")) && statSync(join(root, "src")).isDirectory() ? "src" : "";
+    const sources = listSources(root);
+    const found = override
+        ? { framework: override, evidence: "chosen with --framework" }
+        : detectFramework(root, pkg !== undefined, has, sources);
+    const resolution = String(tsconfig?.compilerOptions?.moduleResolution ?? tsconfig?.compilerOptions?.module ?? "").toLowerCase();
+    const nextAppDir = ["app", "src/app"].find((d) => existsSync(join(root, d)));
+    const nextMajor = has("next")
+        ? Number(/(\d+)/.exec(dependencies.next ?? "")?.[1]) || undefined
+        : undefined;
+    return {
+        root,
+        ...found,
+        packageManager: packageManager(root, pkg?.packageManager),
+        typescript,
+        esm: pkg?.type === "module",
+        importExtension: resolution.startsWith("node16") || resolution.startsWith("nodenext") ? ".js" : "",
+        sourceDir,
+        sources,
+        dependencies,
+        scripts: pkg?.scripts ?? {},
+        web: has("next")
+            ? nextAppDir
+                ? "next-app"
+                : "next-pages"
+            : has("hono")
+                ? "hono"
+                : has("express")
+                    ? "express"
+                    : "node-http",
+        ...(nextAppDir && has("next") ? { nextAppDir } : {}),
+        ...(nextMajor ? { nextMajor } : {}),
+        hasSdk: has("@bondedhq/sdk"),
+    };
+}
+function detectFramework(root, hasPackageJson, has, sources) {
+    if (has("@coinbase/agentkit"))
+        return { framework: "agentkit", evidence: "package.json depends on @coinbase/agentkit" };
+    if (has("@elizaos/core"))
+        return { framework: "eliza", evidence: "package.json depends on @elizaos/core" };
+    const character = characterFile(root);
+    if (character)
+        return { framework: "eliza", evidence: `${character} looks like an ElizaOS character` };
+    for (const name of ["@langchain/langgraph", "@langchain/core", "langchain"])
+        if (has(name))
+            return { framework: "langchain", evidence: `package.json depends on ${name}` };
+    if (has("ai"))
+        return { framework: "ai-sdk", evidence: "package.json depends on ai (the Vercel AI SDK)" };
+    if (has("@modelcontextprotocol/sdk"))
+        return { framework: "mcp", evidence: "package.json depends on @modelcontextprotocol/sdk" };
+    if (!hasPackageJson &&
+        ["pyproject.toml", "requirements.txt", "setup.py"].some((f) => existsSync(join(root, f))))
+        return {
+            framework: "python",
+            evidence: "a Python project (pyproject.toml or requirements.txt)",
+        };
+    return {
+        framework: "unknown",
+        evidence: hasPackageJson
+            ? `no known agent framework in package.json${sources.length ? "" : ", and no source files"}`
+            : "no package.json",
+    };
+}
+/** An ElizaOS character file: JSON with a name and plugins or bio. */
+function characterFile(root) {
+    const candidates = [];
+    for (const dir of ["", "characters"]) {
+        const abs = join(root, dir);
+        if (!existsSync(abs) || !statSync(abs).isDirectory())
+            continue;
+        for (const f of readdirSync(abs))
+            if (f.endsWith(".character.json") || (dir === "characters" && f.endsWith(".json")))
+                candidates.push(dir ? `${dir}/${f}` : f);
+    }
+    return candidates.find((f) => {
+        try {
+            const json = JSON.parse(readFileSync(join(root, f), "utf8"));
+            return typeof json.name === "string" && ("plugins" in json || "bio" in json);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** The package manager, from `packageManager` or the nearest lockfile (here or a parent folder). */
+function packageManager(root, field) {
+    const named = /^(npm|pnpm|yarn|bun)@/.exec(field ?? "")?.[1];
+    if (named)
+        return named;
+    for (let dir = root;; dir = dirname(dir)) {
+        if (existsSync(join(dir, "pnpm-lock.yaml")))
+            return "pnpm";
+        if (existsSync(join(dir, "yarn.lock")))
+            return "yarn";
+        if (existsSync(join(dir, "bun.lockb")) || existsSync(join(dir, "bun.lock")))
+            return "bun";
+        if (existsSync(join(dir, "package-lock.json")))
+            return "npm";
+        if (dirname(dir) === dir || existsSync(join(dir, ".git")))
+            return "npm";
+    }
+}
+/** tsconfig.json, read leniently (comments and trailing commas allowed). */
+function readTsconfig(root) {
+    const path = join(root, "tsconfig.json");
+    if (!existsSync(path))
+        return undefined;
+    const text = readFileSync(path, "utf8")
+        .replace(/("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, (_, s) => s ?? "")
+        .replace(/,(\s*[}\]])/g, "$1");
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+function listSources(root) {
+    const out = [];
+    const walk = (dir) => {
+        if (out.length >= MAX_SOURCES)
+            return;
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.startsWith(".") || SKIP.has(entry.name))
+                continue;
+            const abs = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(abs);
+            else if (entry.isFile() &&
+                SOURCE.test(entry.name) &&
+                !/\.(test|spec|d)\.[a-z]+$/.test(entry.name) &&
+                !/\.config\.[a-z]+$/.test(entry.name))
+                out.push(relative(root, abs).split(sep).join("/"));
+        }
+    };
+    walk(root);
+    return out.sort();
+}
+//# sourceMappingURL=detect.js.map

package/dist/init/diff.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A unified diff of one file (`git diff` style, 3 lines of context). `before` is undefined for a
+ * new file. Line-based longest common subsequence: `init`'s files are small.
+ */
+export declare function unifiedDiff(path: string, before: string | undefined, after: string): string;
+//# sourceMappingURL=diff.d.ts.map

package/dist/init/diff.js

@@ -0,0 +1,98 @@
+/**
+ * A unified diff of one file (`git diff` style, 3 lines of context). `before` is undefined for a
+ * new file. Line-based longest common subsequence: `init`'s files are small.
+ */
+export function unifiedDiff(path, before, after) {
+    const a = before === undefined ? [] : splitLines(before);
+    const b = splitLines(after);
+    const ops = diffLines(a, b);
+    const header = before === undefined ? `--- /dev/null\n+++ b/${path}\n` : `--- a/${path}\n+++ b/${path}\n`;
+    const hunks = [];
+    const CONTEXT = 3;
+    let i = 0;
+    while (i < ops.length) {
+        // The next change.
+        while (i < ops.length && ops[i].kind === " ")
+            i++;
+        if (i >= ops.length)
+            break;
+        const start = Math.max(0, i - CONTEXT);
+        let end = i;
+        // Extend while changes are within 2 * CONTEXT of each other.
+        for (let j = i; j < ops.length; j++) {
+            if (ops[j].kind !== " ")
+                end = j;
+            else if (j - end > 2 * CONTEXT)
+                break;
+        }
+        const stop = Math.min(ops.length, end + CONTEXT + 1);
+        const slice = ops.slice(start, stop);
+        const aStart = ops.slice(0, start).filter((o) => o.kind !== "+").length;
+        const bStart = ops.slice(0, start).filter((o) => o.kind !== "-").length;
+        const aLen = slice.filter((o) => o.kind !== "+").length;
+        const bLen = slice.filter((o) => o.kind !== "-").length;
+        hunks.push(`@@ -${aLen ? aStart + 1 : aStart},${aLen} +${bLen ? bStart + 1 : bStart},${bLen} @@\n` +
+            slice.map((o) => `${o.kind}${o.line}\n`).join(""));
+        i = stop;
+    }
+    return hunks.length ? header + hunks.join("") : "";
+}
+function splitLines(text) {
+    const lines = text.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    return lines;
+}
+function diffLines(a, b) {
+    // Common prefix and suffix first, so the table covers only the changed middle.
+    let pre = 0;
+    while (pre < a.length && pre < b.length && a[pre] === b[pre])
+        pre++;
+    let suf = 0;
+    while (suf < a.length - pre &&
+        suf < b.length - pre &&
+        a[a.length - 1 - suf] === b[b.length - 1 - suf])
+        suf++;
+    const am = a.slice(pre, a.length - suf);
+    const bm = b.slice(pre, b.length - suf);
+    const middle = [];
+    if (am.length * bm.length > 4_000_000) {
+        // Too big to align: show it as replaced.
+        middle.push(...am.map((line) => ({ kind: "-", line })));
+        middle.push(...bm.map((line) => ({ kind: "+", line })));
+    }
+    else {
+        const n = am.length;
+        const m = bm.length;
+        const table = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+        for (let x = n - 1; x >= 0; x--)
+            for (let y = m - 1; y >= 0; y--)
+                table[x][y] =
+                    am[x] === bm[y]
+                        ? table[x + 1][y + 1] + 1
+                        : Math.max(table[x + 1][y], table[x][y + 1]);
+        let x = 0;
+        let y = 0;
+        while (x < n || y < m) {
+            if (x < n && y < m && am[x] === bm[y]) {
+                middle.push({ kind: " ", line: am[x] });
+                x++;
+                y++;
+            }
+            else if (x < n && (y >= m || table[x + 1][y] >= table[x][y + 1])) {
+                middle.push({ kind: "-", line: am[x] });
+                x++;
+            }
+            else {
+                middle.push({ kind: "+", line: bm[y] });
+                y++;
+            }
+        }
+    }
+    return [
+        ...a.slice(0, pre).map((line) => ({ kind: " ", line })),
+        ...middle,
+        ...a.slice(a.length - suf).map((line) => ({ kind: " ", line })),
+    ];
+}
+//# sourceMappingURL=diff.js.map

package/dist/init/plan.d.ts

@@ -0,0 +1,44 @@
+import { type Framework, type Project } from "./detect.js";
+/** One file `init` would write: new (no `before`) or changed. Paths relative to the project. */
+export interface FileChange {
+    path: string;
+    before?: string;
+    after: string;
+    /** What it is for, in a sentence. */
+    why: string;
+}
+/** Everything `init` proposes for a project. Nothing is written until it is applied. */
+export interface InitPlan {
+    framework: Framework;
+    changes: FileChange[];
+    /** What `init` could not change safely: do it by hand (each a sentence or a code line). */
+    manual: string[];
+    /** Things to know (not to do now). */
+    notes: string[];
+    /** Variables the new code reads, for `.env` (names only). */
+    env: string[];
+    /** The packages to add, when they aren't there yet. */
+    install: string[];
+}
+export interface PlanOptions {
+    /** Also add an Agent URL route for the project's web framework. */
+    url?: boolean;
+    /**
+     * Rewrite files init wrote before even when they were edited since (the diff shows what goes).
+     * Off by default: an edited file is kept.
+     */
+    overwriteGenerated?: boolean;
+}
+/**
+ * The first line of every file `init` writes, so a second run knows the file is init's. It is
+ * rewritten only while it still holds exactly what init would write (or with --overwrite-generated).
+ */
+export declare const MARKER = "// Added by `bonded-runner init`";
+/** The production vault's variables (`bondedVaultFromEnv` in @bondedhq/sdk). */
+export declare const VAULT_ENV: string[];
+export declare function planInit(project: Project, options?: PlanOptions): InitPlan;
+/** Adds an import after the file's existing imports (or at the top), unless it is there already. */
+export declare function addImport(text: string, statement: string, specifier: string): string;
+/** What the plan does, framework by framework, in a line: for the summary. */
+export declare function frameworkLine(project: Project): string;
+//# sourceMappingURL=plan.d.ts.map