loopgen 0.1.0

package/dist/adapters/cursor.js

@@ -0,0 +1,41 @@
+export function generateCursorFiles(scan, loops) {
+    return loops.map((loop) => ({
+        path: `.cursor/rules/loopgen-${loop.id}.mdc`,
+        content: cursorRule(scan, loop)
+    }));
+}
+function cursorRule(scan, loop) {
+    return `---
+description: ${loop.goal}
+globs:
+alwaysApply: false
+---
+
+# ${loop.title}
+
+Bounded loop-engineering rule for ${scan.projectName}, generated by loopgen. Apply this rule when working
+on \`${loop.id}\`.
+
+## Goal
+
+${loop.goal}
+
+## Steps
+
+${loop.actions.map((action, index) => `${index + 1}. ${action}`).join("\n")}
+
+## Verify before declaring success
+
+${loop.verification.commands.map((command) => `- \`${command}\``).join("\n")}
+
+Acceptance criteria: ${loop.verification.acceptanceCriteria}
+
+## Guardrails
+
+- Maximum iterations: ${loop.stopCriteria.maxIterations}.
+- Keep maker and checker work separate.
+- Do not read or modify: ${loop.permissions.forbiddenPaths.map((item) => `\`${item}\``).join(", ")}.
+- Log every attempt to \`${loop.stateFile}\`.
+- Stop and ask for human input when: ${loop.stopCriteria.requireHumanInputOn.join("; ")}.
+${loop.verification.requiresHumanCommandDefinition ? "\nThis rule is a draft until the TODO verification command is replaced.\n" : ""}`;
+}

package/dist/adapters/local-model.js

@@ -0,0 +1,172 @@
+export function generateLocalModelFiles(scan, loops, options) {
+    const config = normalizeLocalConfig(options.adapterId, options.config);
+    return [
+        {
+            path: `.loopgen/adapters/${options.adapterId}/config.json`,
+            content: JSON.stringify(renderConfig(scan.projectName, options.adapterId, config), null, 2) + "\n"
+        },
+        ...loops.map((loop) => ({
+            path: `.loopgen/adapters/${options.adapterId}/${loop.id}.md`,
+            content: renderRunbook(scan, loop, options.adapterId, config)
+        }))
+    ];
+}
+export function localModelWarnings(adapterId, config) {
+    if (adapterId !== "ollama" && adapterId !== "openai-compatible")
+        return [];
+    const warnings = [];
+    if (!config?.model?.trim() || config.model === "TODO_MODEL") {
+        warnings.push(`${adapterId} needs a model name before the generated runbook can call the local runtime.`);
+    }
+    if (!config?.baseUrl?.trim()) {
+        warnings.push(`${adapterId} needs a base URL before the generated runbook can call the local runtime.`);
+    }
+    return warnings;
+}
+function normalizeLocalConfig(adapterId, config) {
+    if (adapterId === "ollama") {
+        return {
+            preset: config.preset ?? "ollama",
+            baseUrl: config.baseUrl?.trim() || "http://localhost:11434",
+            model: config.model?.trim() || "TODO_MODEL"
+        };
+    }
+    return {
+        preset: config.preset ?? "lm-studio",
+        baseUrl: config.baseUrl?.trim() || "http://localhost:1234/v1",
+        model: config.model?.trim() || "TODO_MODEL",
+        apiKeyEnv: config.apiKeyEnv?.trim() ?? ""
+    };
+}
+function renderConfig(projectName, adapterId, config) {
+    return {
+        version: "0.1",
+        project: projectName,
+        adapter: adapterId,
+        preset: config.preset,
+        baseUrl: config.baseUrl,
+        model: config.model,
+        apiKeyEnv: adapterId === "openai-compatible" ? config.apiKeyEnv || undefined : undefined,
+        executesAutomatically: false,
+        warnings: localModelWarnings(adapterId, config),
+        notes: [
+            "loopgen generates local model runbooks only; it does not execute the model.",
+            "Do not write API keys or secrets into this file."
+        ]
+    };
+}
+function renderRunbook(scan, loop, adapterId, config) {
+    return `# ${loop.title} local model runbook
+
+Project: ${scan.projectName}
+Loop id: ${loop.id}
+Adapter: ${adapterId}
+Preset: ${config.preset ?? "custom"}
+Base URL: ${config.baseUrl}
+Model: ${config.model}
+
+> loopgen generated this runbook for a local/open-source model runtime. It does not execute the model automatically.
+
+## Goal
+
+${loop.goal}
+
+Expected outcome: ${loop.expectedOutcome}
+
+## Context to provide
+
+${loop.contextSources.map((source) => `- ${source}`).join("\n")}
+
+## Prompt template
+
+\`\`\`text
+You are running a bounded loop engineering workflow for ${scan.projectName}.
+
+Goal:
+${loop.goal}
+
+Expected outcome:
+${loop.expectedOutcome}
+
+Context sources to inspect or summarize:
+${loop.contextSources.map((source) => `- ${source}`).join("\n")}
+
+Loop steps:
+${loop.actions.map((action, index) => `${index + 1}. ${action}`).join("\n")}
+
+Verification commands:
+${loop.verification.commands.map((command) => `- ${command}`).join("\n")}
+
+State file:
+${loop.stateFile}
+
+Stop and ask for human input when:
+${loop.stopCriteria.requireHumanInputOn.map((condition) => `- ${condition}`).join("\n")}
+
+Return a concise plan for the next maker iteration, the files likely involved, verification to run, and state-file notes to append.
+\`\`\`
+
+## Curl example
+
+${adapterId === "ollama" ? ollamaCurlExample(config, loop) : openAiCompatibleCurlExample(config, loop)}
+
+## Verification
+
+Run these commands before declaring success:
+
+${loop.verification.commands.map((command) => `- \`${command}\``).join("\n")}
+
+Acceptance criteria: ${loop.verification.acceptanceCriteria}
+
+## Safety
+
+- State file: \`${loop.stateFile}\`
+- Maximum iterations: ${loop.stopCriteria.maxIterations}
+- Timeout minutes: ${loop.stopCriteria.timeoutMinutes}
+- Network allowed: ${loop.permissions.allowNetwork ? "yes" : "no"}
+- PR creation allowed: ${loop.permissions.allowPrCreation ? "yes" : "no"}
+- Do not read or modify: ${loop.permissions.forbiddenPaths.map((item) => `\`${item}\``).join(", ")}
+
+${localModelWarnings(adapterId, config).length ? `## TODO\n\n${localModelWarnings(adapterId, config).map((warning) => `- ${warning}`).join("\n")}\n` : ""}
+`;
+}
+function ollamaCurlExample(config, loop) {
+    return `\`\`\`bash
+curl ${config.baseUrl}/api/chat \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "model": "${config.model}",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are a careful loop engineering assistant. Keep changes bounded, verify before success, and update the loop state file."
+      },
+      {
+        "role": "user",
+        "content": "Run the next maker iteration for loop ${loop.id}. Use the prompt template in this runbook."
+      }
+    ]
+  }'
+\`\`\``;
+}
+function openAiCompatibleCurlExample(config, loop) {
+    const authLine = config.apiKeyEnv ? `  -H "Authorization: Bearer $${config.apiKeyEnv}" \\\n` : "";
+    return `\`\`\`bash
+curl ${config.baseUrl}/chat/completions \\
+  -H "Content-Type: application/json" \\
+${authLine}  -d '{
+    "model": "${config.model}",
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are a careful loop engineering assistant. Keep changes bounded, verify before success, and update the loop state file."
+      },
+      {
+        "role": "user",
+        "content": "Run the next maker iteration for loop ${loop.id}. Use the prompt template in this runbook."
+      }
+    ]
+  }'
+\`\`\``;
+}

package/dist/adapters/windsurf.js

@@ -0,0 +1,41 @@
+export function generateWindsurfFiles(scan, loops) {
+    return [
+        {
+            path: ".windsurfrules",
+            content: renderWindsurfRules(scan, loops)
+        }
+    ];
+}
+function renderWindsurfRules(scan, loops) {
+    const loopSections = loops.map((loop) => renderLoopSection(loop)).join("\n\n");
+    return `# loopgen rules for ${scan.projectName}
+
+Generated by loopgen. These are bounded, verifiable loops with safety rails for Windsurf/Cascade. Keep
+changes small, run verification, and stop at the iteration limit.
+
+## Global guardrails
+
+- Make the smallest change that satisfies the goal.
+- Run verification commands before declaring success.
+- Keep maker and checker work separate.
+- Never read or modify secret or credential files.
+- Log every attempt to the loop's state file and stop when a stop condition is met.
+
+${loopSections}
+`;
+}
+function renderLoopSection(loop) {
+    return `## ${loop.title} (${loop.id})
+
+${loop.goal}
+
+Steps:
+${loop.actions.map((action, index) => `${index + 1}. ${action}`).join("\n")}
+
+Verify:
+${loop.verification.commands.map((command) => `- \`${command}\``).join("\n")}
+
+Guardrails: max ${loop.stopCriteria.maxIterations} iterations; state file \`${loop.stateFile}\`; do not touch ${loop.permissions.forbiddenPaths
+        .map((item) => `\`${item}\``)
+        .join(", ")}.${loop.verification.requiresHumanCommandDefinition ? " Draft until a real verification command is set." : ""}`;
+}

package/dist/cli.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import readline from "node:readline/promises";
+import { Command } from "commander";
+import { applyGeneratedFiles } from "./core/fs-plan.js";
+import { demoProjectRoot, generateLoopProject } from "./core/generator.js";
+import { scanProject } from "./core/scanner.js";
+import { TEMPLATE_DEFINITIONS } from "./core/templates.js";
+import { startLoopgenServer } from "./server.js";
+import { DEFAULT_ADAPTER_IDS, parseAdapterIds } from "./core/adapters.js";
+const PROJECT_MANIFESTS = [
+    "package.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "go.mod",
+    "Cargo.toml",
+    "pom.xml",
+    "build.gradle",
+    "Gemfile",
+    "composer.json"
+];
+function looksLikeProject(dir) {
+    return PROJECT_MANIFESTS.some((file) => existsSync(path.join(dir, file)));
+}
+const program = new Command();
+program
+    .name("loopgen")
+    .description("Generate bounded, verifiable AI agent configs for Codex, Claude, Cursor, and local models — with safety rails baked in.")
+    .version("0.1.0");
+program
+    .command("init")
+    .argument("[project]", "project directory", ".")
+    .option("-p, --port <port>", "port for the local wizard", "8787")
+    .option("--host <host>", "host for the local wizard", "127.0.0.1")
+    .option("--no-open", "do not open the browser automatically")
+    .description("Start the local Web wizard.")
+    .action(async (project, options) => {
+    const projectRoot = path.resolve(project);
+    const isProject = looksLikeProject(projectRoot);
+    const { url } = await startLoopgenServer({
+        projectRoot,
+        host: options.host,
+        port: Number(options.port)
+    });
+    const openUrl = isProject ? `${url}/?project=${encodeURIComponent(projectRoot)}` : url;
+    console.log(`loopgen wizard running at ${url}`);
+    if (isProject) {
+        console.log(`Project: ${projectRoot}`);
+    }
+    else {
+        console.log("No project manifest detected here — opening the built-in demo so you can explore safely.");
+        console.log("Run `loopgen init <path-to-your-project>` to scan a real project.");
+    }
+    if (options.open) {
+        openBrowser(openUrl);
+    }
+});
+program
+    .command("scan")
+    .argument("[project]", "project directory", ".")
+    .option("--json", "print the full scan as JSON")
+    .option("--demo", "scan the built-in demo project")
+    .description("Scan a project and infer loop inputs.")
+    .action(async (project, options) => {
+    const scan = await scanProject(options.demo ? demoProjectRoot() : path.resolve(project));
+    if (options.json) {
+        console.log(JSON.stringify(scan, null, 2));
+        return;
+    }
+    console.log(`${scan.projectName} (${scan.primaryLanguage})`);
+    console.log(`Root: ${scan.root}`);
+    console.log(`Package managers: ${scan.packageManagers.join(", ") || "none detected"}`);
+    console.log(`Commands: ${formatCommands(scan.commands)}`);
+    console.log(`CI: ${scan.ci.workflowFiles.join(", ") || "none detected"}`);
+    for (const warning of scan.warnings) {
+        console.warn(`Warning: ${warning}`);
+    }
+});
+program
+    .command("create")
+    .argument("[template]", "template id or 'all'", "all")
+    .argument("[project]", "project directory", ".")
+    .option("--adapters <items>", "comma-separated adapters", DEFAULT_ADAPTER_IDS.join(","))
+    .option("--ollama-model <model>", "model name for the Ollama adapter")
+    .option("--ollama-base-url <url>", "base URL for the Ollama adapter")
+    .option("--openai-compatible-model <model>", "model name for the OpenAI-compatible adapter")
+    .option("--openai-compatible-base-url <url>", "base URL for the OpenAI-compatible adapter")
+    .option("--openai-compatible-api-key-env <name>", "environment variable name for an OpenAI-compatible API key")
+    .option("--json", "print generated file metadata as JSON")
+    .option("--demo", "use the built-in demo project")
+    .description("Create loop configuration in memory and print a summary.")
+    .action(async (template, project, options) => {
+    const result = await generateLoopProject(buildGenerationOptions(project, template, options.adapters, options.demo ? "demo" : "project", buildAdapterConfigs(options)));
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    printGenerationSummary(result);
+});
+program
+    .command("preview")
+    .argument("[project]", "project directory", ".")
+    .option("--templates <items>", "comma-separated loop templates", "all")
+    .option("--adapters <items>", "comma-separated adapters", DEFAULT_ADAPTER_IDS.join(","))
+    .option("--ollama-model <model>", "model name for the Ollama adapter")
+    .option("--ollama-base-url <url>", "base URL for the Ollama adapter")
+    .option("--openai-compatible-model <model>", "model name for the OpenAI-compatible adapter")
+    .option("--openai-compatible-base-url <url>", "base URL for the OpenAI-compatible adapter")
+    .option("--openai-compatible-api-key-env <name>", "environment variable name for an OpenAI-compatible API key")
+    .option("--demo", "use the built-in demo project")
+    .description("Preview the files loopgen would write.")
+    .action(async (project, options) => {
+    const result = await generateLoopProject(buildGenerationOptions(project, options.templates, options.adapters, options.demo ? "demo" : "project", buildAdapterConfigs(options)));
+    printGenerationSummary(result);
+    console.log("\nDiff preview:\n");
+    console.log(result.diff || "No changes.");
+});
+program
+    .command("apply")
+    .argument("[project]", "project directory", ".")
+    .option("--templates <items>", "comma-separated loop templates", "all")
+    .option("--adapters <items>", "comma-separated adapters", DEFAULT_ADAPTER_IDS.join(","))
+    .option("--ollama-model <model>", "model name for the Ollama adapter")
+    .option("--ollama-base-url <url>", "base URL for the Ollama adapter")
+    .option("--openai-compatible-model <model>", "model name for the OpenAI-compatible adapter")
+    .option("--openai-compatible-base-url <url>", "base URL for the OpenAI-compatible adapter")
+    .option("--openai-compatible-api-key-env <name>", "environment variable name for an OpenAI-compatible API key")
+    .option("-y, --yes", "apply without an interactive confirmation")
+    .description("Write generated loop files after confirmation.")
+    .action(async (project, options) => {
+    const result = await generateLoopProject(buildGenerationOptions(project, options.templates, options.adapters, "project", buildAdapterConfigs(options)));
+    printGenerationSummary(result);
+    console.log("\nDiff preview:\n");
+    console.log(result.diff || "No changes.");
+    if (!options.yes && !(await confirm("Apply these files?"))) {
+        console.log("Canceled.");
+        return;
+    }
+    const written = await applyGeneratedFiles(result.scan.root, result.files);
+    console.log(`Wrote ${written.length} files.`);
+});
+program.parseAsync(process.argv).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});
+function buildGenerationOptions(project, templates, adapters, experienceMode = "project", adapterConfigs) {
+    return {
+        projectRoot: path.resolve(project),
+        experienceMode,
+        selectedTemplates: parseTemplates(templates),
+        adapters: parseAdapters(adapters),
+        adapterConfigs
+    };
+}
+function parseTemplates(value) {
+    if (value === "all")
+        return undefined;
+    const ids = value.split(",").map((item) => item.trim()).filter(Boolean);
+    const valid = new Set(TEMPLATE_DEFINITIONS.map((template) => template.id));
+    for (const id of ids) {
+        if (!valid.has(id)) {
+            throw new Error(`Unknown template: ${id}`);
+        }
+    }
+    return ids;
+}
+function parseAdapters(value) {
+    return parseAdapterIds(value);
+}
+function buildAdapterConfigs(options) {
+    return {
+        ollama: {
+            preset: "ollama",
+            model: options.ollamaModel,
+            baseUrl: options.ollamaBaseUrl
+        },
+        "openai-compatible": {
+            preset: options.openaiCompatibleBaseUrl ? "custom-openai-compatible" : "lm-studio",
+            model: options.openaiCompatibleModel,
+            baseUrl: options.openaiCompatibleBaseUrl,
+            apiKeyEnv: options.openaiCompatibleApiKeyEnv
+        }
+    };
+}
+function printGenerationSummary(result) {
+    console.log(`Project: ${result.scan.projectName}`);
+    console.log(`Loops: ${result.loops.map((loop) => loop.id).join(", ")}`);
+    console.log(`Files: ${result.files.length}`);
+    for (const warning of result.warnings) {
+        console.warn(`Warning: ${warning}`);
+    }
+}
+function formatCommands(commands) {
+    const entries = Object.entries(commands).filter(([, command]) => command);
+    return entries.length ? entries.map(([name, command]) => `${name}=${command}`).join(", ") : "none inferred";
+}
+async function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(`${question} [y/N] `);
+    rl.close();
+    return /^y(es)?$/i.test(answer.trim());
+}
+function openBrowser(url) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", url] : [url];
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.unref();
+}

package/dist/core/adapters.js

@@ -0,0 +1,162 @@
+export const DEFAULT_ADAPTER_IDS = ["codex", "claude"];
+export const ADAPTER_DEFINITIONS = [
+    {
+        id: "agents-md",
+        name: "AGENTS.md",
+        vendor: "Cross-tool standard",
+        description: "One AGENTS.md read by Claude Code, Codex, Cursor, Copilot, Gemini CLI, Aider, and more",
+        outputPath: "AGENTS.md",
+        files: ["AGENTS.md"],
+        capabilities: ["Universal agent instructions", "Per-loop sections", "Safety rules"],
+        prBehavior: "Describes loop behavior; does not create PRs by itself.",
+        safetyNotes: ["Portable across most AI coding agents.", "Forbidden paths are listed per loop."],
+        configurable: false
+    },
+    {
+        id: "cursor",
+        name: "Cursor",
+        vendor: "Cursor",
+        description: "Project rules as .cursor/rules/*.mdc files",
+        outputPath: ".cursor/rules/",
+        files: ["loopgen-*.mdc"],
+        capabilities: ["Cursor project rule", "MDC frontmatter", "Per-loop guardrails"],
+        prBehavior: "Guides Cursor agents; does not create PRs by itself.",
+        safetyNotes: ["Each rule lists forbidden paths and iteration limits."],
+        configurable: false
+    },
+    {
+        id: "windsurf",
+        name: "Windsurf",
+        vendor: "Codeium",
+        description: "A .windsurfrules file for Windsurf/Cascade",
+        outputPath: ".windsurfrules",
+        files: [".windsurfrules"],
+        capabilities: ["Windsurf rules", "Global guardrails", "Per-loop sections"],
+        prBehavior: "Guides Windsurf agents; does not create PRs by itself.",
+        safetyNotes: ["Includes global and per-loop safety guardrails."],
+        configurable: false
+    },
+    {
+        id: "codex",
+        name: "Codex",
+        vendor: "OpenAI",
+        description: "Skills, automation prompts, checker TOML",
+        outputPath: ".codex/",
+        files: ["skills/*/SKILL.md", "automations/*.md", "agents/*-checker.toml"],
+        capabilities: ["Automation prompt", "Project skill", "Checker agent"],
+        prBehavior: "Can prepare a PR only when the loop allows PR creation.",
+        safetyNotes: ["Dry-run through preview before files are applied.", "Forbidden paths are listed in each generated loop."],
+        configurable: false
+    },
+    {
+        id: "claude",
+        name: "Claude",
+        vendor: "Anthropic",
+        description: "Skills, loop guides, checker notes",
+        outputPath: ".claude/",
+        files: ["skills/*/SKILL.md", "loops/*.md", "agents/*-checker.md"],
+        capabilities: ["Claude skill", "Loop guide", "Checker notes"],
+        prBehavior: "Records PR handling guidance; it does not create PRs by default.",
+        safetyNotes: ["Requires the user's local Claude Code setup.", "State files record attempts and blockers."],
+        configurable: false
+    },
+    {
+        id: "ollama",
+        name: "Ollama",
+        vendor: "Local runtime",
+        description: "Local model config and native Ollama chat runbooks",
+        outputPath: ".loopgen/adapters/ollama/",
+        files: ["config.json", "*.md"],
+        capabilities: ["Local model runbook", "Native /api/chat curl", "Prompt template"],
+        prBehavior: "Does not create PRs; generated runbooks guide local model usage.",
+        safetyNotes: ["Uses a local endpoint by default.", "No API keys are written into generated files.", "loopgen does not execute the model automatically."],
+        configurable: true
+    },
+    {
+        id: "openai-compatible",
+        name: "OpenAI-compatible",
+        vendor: "Local or self-hosted runtime",
+        description: "Runbooks for LM Studio, llama.cpp, vLLM, LocalAI, and similar servers",
+        outputPath: ".loopgen/adapters/openai-compatible/",
+        files: ["config.json", "*.md"],
+        capabilities: ["OpenAI-style chat completions", "Preset base URLs", "Prompt template"],
+        prBehavior: "Does not create PRs; generated runbooks guide local model usage.",
+        safetyNotes: ["References API keys by environment variable name only.", "Works with local or private compatible servers.", "loopgen does not execute the model automatically."],
+        configurable: true
+    }
+];
+export const ADAPTER_IDS = ADAPTER_DEFINITIONS.map((adapter) => adapter.id);
+export const ADAPTER_PRESETS = {
+    ollama: {
+        adapterId: "ollama",
+        label: "Ollama",
+        baseUrl: "http://localhost:11434",
+        description: "Native Ollama API server."
+    },
+    "lm-studio": {
+        adapterId: "openai-compatible",
+        label: "LM Studio",
+        baseUrl: "http://localhost:1234/v1",
+        description: "LM Studio local server with OpenAI-compatible endpoints."
+    },
+    "llama-cpp": {
+        adapterId: "openai-compatible",
+        label: "llama.cpp",
+        baseUrl: "http://localhost:8080/v1",
+        description: "llama.cpp server with OpenAI-compatible endpoints."
+    },
+    "custom-openai-compatible": {
+        adapterId: "openai-compatible",
+        label: "Custom",
+        baseUrl: "http://localhost:8000/v1",
+        description: "Custom OpenAI-compatible chat completions server."
+    }
+};
+export function isAdapterId(value) {
+    return ADAPTER_IDS.includes(value);
+}
+export function parseAdapterIds(value) {
+    const ids = value.split(",").map((item) => item.trim()).filter(Boolean);
+    for (const id of ids) {
+        if (!isAdapterId(id)) {
+            throw new Error(`Unknown adapter: ${id}`);
+        }
+    }
+    return ids.length ? ids : DEFAULT_ADAPTER_IDS;
+}
+export function adapterDefinitionFor(id) {
+    return ADAPTER_DEFINITIONS.find((adapter) => adapter.id === id);
+}
+export function defaultAdapterConfig(id) {
+    if (id === "ollama") {
+        return {
+            preset: "ollama",
+            baseUrl: ADAPTER_PRESETS.ollama.baseUrl,
+            model: ""
+        };
+    }
+    if (id === "openai-compatible") {
+        return {
+            preset: "lm-studio",
+            baseUrl: ADAPTER_PRESETS["lm-studio"].baseUrl,
+            model: "",
+            apiKeyEnv: ""
+        };
+    }
+    return {};
+}
+export function normalizeAdapterConfigs(configs) {
+    const normalized = {};
+    for (const adapter of ADAPTER_DEFINITIONS) {
+        const defaults = defaultAdapterConfig(adapter.id);
+        const provided = configs?.[adapter.id] ?? {};
+        normalized[adapter.id] = {
+            ...defaults,
+            ...definedAdapterConfig(provided)
+        };
+    }
+    return normalized;
+}
+function definedAdapterConfig(config) {
+    return Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined));
+}

package/dist/core/diff.js

@@ -0,0 +1,29 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function createPreviewDiff(projectRoot, files) {
+    const chunks = [];
+    for (const file of files) {
+        const absolute = path.join(projectRoot, file.path);
+        const existing = await fs.readFile(absolute, "utf8").catch(() => undefined);
+        if (existing === file.content) {
+            continue;
+        }
+        chunks.push(renderFileDiff(file.path, existing, file.content));
+    }
+    return chunks.join("\n");
+}
+export function renderFileDiff(filePath, before, after) {
+    const beforeLines = before?.split("\n") ?? [];
+    const afterLines = after.split("\n");
+    const oldLabel = before === undefined ? "/dev/null" : `a/${filePath}`;
+    const lines = [`--- ${oldLabel}`, `+++ b/${filePath}`];
+    if (before === undefined) {
+        lines.push(`@@ -0,0 +1,${afterLines.length} @@`);
+        lines.push(...afterLines.map((line) => `+${line}`));
+        return lines.join("\n");
+    }
+    lines.push(`@@ -1,${beforeLines.length} +1,${afterLines.length} @@`);
+    lines.push(...beforeLines.map((line) => `-${line}`));
+    lines.push(...afterLines.map((line) => `+${line}`));
+    return lines.join("\n");
+}

package/dist/core/fs-plan.js

@@ -0,0 +1,12 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function applyGeneratedFiles(projectRoot, files) {
+    const written = [];
+    for (const file of files) {
+        const target = path.join(projectRoot, file.path);
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(target, file.content, "utf8");
+        written.push(file.path);
+    }
+    return written;
+}