agentcn 0.1.0

package/dist/add.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const addCommand: Command;

package/dist/add.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommand = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const path_exists_1 = require("path-exists");
+const commander_1 = require("commander");
+function getRegistryUrl(registryPath) {
+    if (registryPath) {
+        if (registryPath.startsWith("http"))
+            return registryPath;
+        const resolved = path.resolve(process.cwd(), registryPath);
+        if ((0, path_exists_1.pathExistsSync)(resolved))
+            return resolved;
+    }
+    // Default: monorepo kit/public/r (packages/agentcn/cli/dist -> ../../../public/r)
+    const scriptDir = path.dirname(process.argv[1] || process.cwd());
+    const localRegistry = path.resolve(scriptDir, "../../../public/r");
+    if ((0, path_exists_1.pathExistsSync)(localRegistry))
+        return localRegistry;
+    return "http://localhost:3000/r";
+}
+async function fetchRegistryItem(agentName, registryBase) {
+    if (registryBase.startsWith("http")) {
+        const url = `${registryBase.replace(/\/$/, "")}/${agentName}.json`;
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`Agent "${agentName}" not found at ${url}`);
+        return res.json();
+    }
+    const filePath = path.join(registryBase, `${agentName}.json`);
+    if (!(0, path_exists_1.pathExistsSync)(filePath)) {
+        throw new Error(`Agent "${agentName}" not found at ${filePath}`);
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+}
+function detectPackageManager(cwd) {
+    if ((0, path_exists_1.pathExistsSync)(path.join(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if ((0, path_exists_1.pathExistsSync)(path.join(cwd, "yarn.lock")))
+        return "yarn";
+    return "npm";
+}
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function mergeEnvExample(cwd, envVars) {
+    const envPath = path.join(cwd, ".env.example");
+    let existing = "";
+    if ((0, path_exists_1.pathExistsSync)(envPath)) {
+        existing = fs.readFileSync(envPath, "utf-8");
+    }
+    const lines = [];
+    for (const [key, value] of Object.entries(envVars)) {
+        if (!existing.includes(`${key}=`)) {
+            lines.push(`# Required for agent\n${key}=${value}`);
+        }
+    }
+    if (lines.length > 0) {
+        const toAppend = "\n\n" + lines.join("\n") + "\n";
+        fs.appendFileSync(envPath, toAppend);
+    }
+}
+function addTsconfigPaths(cwd) {
+    const tsconfigPath = path.join(cwd, "tsconfig.json");
+    if (!(0, path_exists_1.pathExistsSync)(tsconfigPath))
+        return;
+    try {
+        const content = fs.readFileSync(tsconfigPath, "utf-8");
+        const config = JSON.parse(content);
+        const comp = config.compilerOptions ?? {};
+        const paths = comp.paths ?? {};
+        if (!paths["@/agents/*"]) {
+            paths["@/agents/*"] = ["./ai/agents/*"];
+        }
+        if (!paths["@/tools/*"]) {
+            paths["@/tools/*"] = ["./ai/tools/*"];
+        }
+        comp.paths = paths;
+        config.compilerOptions = comp;
+        fs.writeFileSync(tsconfigPath, JSON.stringify(config, null, 2));
+    }
+    catch {
+        // skip if tsconfig is invalid
+    }
+}
+async function runAdd(agentName, options) {
+    const cwd = process.cwd();
+    const registryBase = getRegistryUrl(options.registry);
+    console.log(`\n  Adding ${agentName}...\n`);
+    const item = await fetchRegistryItem(agentName, registryBase);
+    for (const file of item.files) {
+        const target = file.target ?? file.path;
+        const destPath = path.join(cwd, target);
+        ensureDir(path.dirname(destPath));
+        fs.writeFileSync(destPath, file.content, "utf-8");
+        console.log(`  ✓ ${target}`);
+    }
+    if (item.envVars && Object.keys(item.envVars).length > 0) {
+        mergeEnvExample(cwd, item.envVars);
+        console.log(`  ✓ .env.example updated`);
+    }
+    addTsconfigPaths(cwd);
+    console.log(`  ✓ tsconfig paths updated`);
+    if (item.dependencies && item.dependencies.length > 0) {
+        const pm = detectPackageManager(cwd);
+        const deps = item.dependencies.join(" ");
+        console.log(`\n  Installing dependencies: ${deps}\n`);
+        const { execSync } = await import("child_process");
+        const cmd = pm === "pnpm"
+            ? `pnpm add ${deps}`
+            : pm === "yarn"
+                ? `yarn add ${deps}`
+                : `npm install ${deps}`;
+        execSync(cmd, { cwd, stdio: "inherit" });
+    }
+    const agentVarLower = agentName.split("-")[0] + "Agent";
+    console.log(`\n  Done! Add an API route to use the agent:\n`);
+    console.log(`  // app/api/chat/route.ts (Next.js App Router)`);
+    console.log(`  import { ${agentVarLower} } from "@/agents/${agentName}";`);
+    console.log(`  import { convertToModelMessages } from "ai";`);
+    console.log(`  // const result = ${agentVarLower}(modelMessages);`);
+    console.log(`  // return result.toUIMessageStreamResponse();\n`);
+}
+exports.addCommand = new commander_1.Command("add")
+    .description("Add an agent to your project")
+    .argument("<agent>", "Agent name (e.g. file-agent)")
+    .option("-r, --registry <path|url>", "Registry path or URL (default: kit/public/r when present, else http://localhost:3000/r)")
+    .action(runAdd);

package/dist/commands/add.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import type { AddOptionsInput } from "../types.js";
+type ConfirmFn = (message: string, defaultValue?: boolean) => Promise<boolean>;
+type AddRuntimeHooks = {
+    confirm?: ConfirmFn;
+};
+export declare function runAddCommand(agentName: string, input: AddOptionsInput, hooks?: AddRuntimeHooks): Promise<void>;
+export declare const addCommand: Command;
+export {};

package/dist/commands/add.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommand = void 0;
+exports.runAddCommand = runAddCommand;
+const commander_1 = require("commander");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const config_js_1 = require("../lib/config.js");
+const deps_js_1 = require("../lib/deps.js");
+const install_plan_js_1 = require("../lib/install-plan.js");
+const registry_js_1 = require("../lib/registry.js");
+const logger_js_1 = require("../utils/logger.js");
+const prompt_js_1 = require("../utils/prompt.js");
+const spinner_js_1 = require("../utils/spinner.js");
+const AGENT_ALIASES = {
+    fileagent: "file-agent",
+    file_agent: "file-agent",
+    webagent: "web-agent",
+    web_agent: "web-agent",
+};
+function normalizeAgentName(input) {
+    const trimmed = input.trim();
+    const alias = AGENT_ALIASES[trimmed.toLowerCase()];
+    if (alias)
+        return { value: alias, aliased: true };
+    const normalized = trimmed.replace(/_/g, "-").toLowerCase();
+    if (normalized !== trimmed) {
+        return { value: normalized, aliased: true };
+    }
+    return { value: trimmed, aliased: false };
+}
+function printSection(title) {
+    logger_js_1.logger.break();
+    logger_js_1.logger.info(title);
+}
+async function runAddCommand(agentName, input, hooks = {}) {
+    const confirm = hooks.confirm ?? prompt_js_1.confirmAction;
+    const parsed = (0, registry_js_1.parseAddOptions)(input, process.cwd());
+    const normalizedAgent = normalizeAgentName(agentName);
+    if (normalizedAgent.aliased) {
+        logger_js_1.logger.warn(`Using canonical agent name "${normalizedAgent.value}" for "${agentName}".`);
+    }
+    logger_js_1.logger.break();
+    logger_js_1.logger.info(`Adding ${normalizedAgent.value}...`);
+    logger_js_1.logger.break();
+    printSection("Resolving registry");
+    const loadSpin = (0, spinner_js_1.spinner)("Resolving source and loading agent...");
+    loadSpin.start();
+    const registryBase = (0, registry_js_1.resolveRegistrySource)(parsed.registry, parsed.cwd);
+    const item = await (0, registry_js_1.loadRegistryItem)(normalizedAgent.value, registryBase);
+    loadSpin.succeed(`Loaded ${item.name} from registry`);
+    logger_js_1.logger.info(`  Source: ${registryBase}`);
+    let actions = (0, install_plan_js_1.planInstall)(item, parsed.cwd, {
+        overwrite: parsed.overwrite,
+    });
+    const summary = {
+        create: actions.filter((a) => a.action === "create").map((a) => a.targetPath),
+        update: actions.filter((a) => a.action === "update").map((a) => a.targetPath),
+        skip: actions.filter((a) => a.action === "skip").map((a) => a.targetPath),
+    };
+    printSection("Plan summary");
+    logger_js_1.logger.info(`  Files: ${summary.create.length} create, ${summary.update.length} update, ${summary.skip.length} skip`);
+    if (summary.skip.length > 0 && !parsed.overwrite) {
+        logger_js_1.logger.info("  Note: existing files are currently marked as skip.");
+    }
+    if (parsed.verbose) {
+        for (const file of summary.create)
+            logger_js_1.logger.info(`  + create ${file}`);
+        for (const file of summary.update)
+            logger_js_1.logger.info(`  ~ update ${file}`);
+        for (const file of summary.skip)
+            logger_js_1.logger.info(`  - skip   ${file}`);
+    }
+    if (!parsed.dryRun &&
+        !parsed.overwrite &&
+        summary.skip.length > 0 &&
+        !parsed.yes) {
+        const shouldOverwrite = await confirm(`Found ${summary.skip.length} existing file(s). Overwrite them?`, false);
+        if (shouldOverwrite) {
+            actions = (0, install_plan_js_1.planInstall)(item, parsed.cwd, { overwrite: true });
+        }
+    }
+    if (parsed.dryRun) {
+        logger_js_1.logger.info("  Dry run enabled: no files were written.");
+    }
+    else {
+        printSection("Applying files");
+        const applySpin = (0, spinner_js_1.spinner)("Applying file changes...");
+        applySpin.start();
+        const applied = (0, install_plan_js_1.applyInstallPlan)(actions);
+        applySpin.succeed("Applied file changes");
+        logger_js_1.logger.info(`  Files: ${applied.created.length} created, ${applied.updated.length} updated, ${applied.skipped.length} skipped`);
+        if (parsed.verbose) {
+            for (const file of applied.created)
+                logger_js_1.logger.info(`  ✓ ${file}`);
+            for (const file of applied.updated)
+                logger_js_1.logger.info(`  ✓ ${file} (updated)`);
+            for (const file of applied.skipped)
+                logger_js_1.logger.info(`  - ${file} (skipped)`);
+        }
+    }
+    printSection("Config updates");
+    let envAdded = [];
+    if (item.envVars && Object.keys(item.envVars).length > 0) {
+        const envExamplePath = node_path_1.default.join(parsed.cwd, ".env.example");
+        const shouldUpdateEnv = parsed.yes || (0, node_fs_1.existsSync)(envExamplePath)
+            ? true
+            : await confirm("No .env.example found. Create and append required env keys?", true);
+        if (shouldUpdateEnv) {
+            envAdded = (0, config_js_1.mergeEnvExample)(parsed.cwd, item.envVars, { dryRun: parsed.dryRun });
+        }
+        else {
+            logger_js_1.logger.info("  Env: skipped");
+        }
+    }
+    if (envAdded.length > 0) {
+        logger_js_1.logger.info(parsed.dryRun
+            ? `  Env: would add ${envAdded.join(", ")}`
+            : `  Env: updated (${envAdded.join(", ")})`);
+    }
+    const tsconfigUpdated = (0, config_js_1.updateTsconfigPaths)(parsed.cwd, { dryRun: parsed.dryRun });
+    if (tsconfigUpdated) {
+        logger_js_1.logger.info(parsed.dryRun
+            ? "  tsconfig: paths would be updated"
+            : "  tsconfig: paths updated");
+    }
+    printSection("Installing dependencies");
+    const shouldInstallDeps = parsed.dryRun || parsed.yes
+        ? true
+        : await confirm("Install agent dependencies now?", true);
+    let depsInstalled = [];
+    if (!shouldInstallDeps) {
+        logger_js_1.logger.info("  Dependencies: skipped by user");
+    }
+    else {
+        const depSpin = (0, spinner_js_1.spinner)("Installing dependencies...");
+        if (!parsed.verbose && !parsed.dryRun)
+            depSpin.start();
+        depsInstalled = (0, deps_js_1.installDependencies)(parsed.cwd, item.dependencies, {
+            dryRun: parsed.dryRun,
+            verbose: parsed.verbose,
+        });
+        if (!parsed.verbose && !parsed.dryRun)
+            depSpin.succeed("Dependencies installed");
+        if (depsInstalled.length > 0) {
+            logger_js_1.logger.info(parsed.dryRun
+                ? `  Dependencies: would install ${depsInstalled.join(", ")}`
+                : `  Dependencies: installed ${depsInstalled.join(", ")}`);
+        }
+        else {
+            logger_js_1.logger.info("  Dependencies: none required");
+        }
+    }
+    printSection("Done");
+    logger_js_1.logger.break();
+    logger_js_1.logger.success("Done!");
+    logger_js_1.logger.info("Next steps:");
+    logger_js_1.logger.info("  - Review created/updated files and run your formatter if needed.");
+    if (envAdded.length > 0) {
+        logger_js_1.logger.info(`  - Set environment values: ${envAdded.join(", ")}`);
+    }
+    logger_js_1.logger.info("  - Run your app and test the installed agent flow.");
+    logger_js_1.logger.info("  - Use --dry-run and --verbose for troubleshooting.");
+    logger_js_1.logger.break();
+}
+exports.addCommand = new commander_1.Command("add")
+    .description("Add an agent to your project")
+    .argument("<agent>", "Agent name (e.g. file-agent)")
+    .option("-r, --registry <path|url>", "Registry path or URL")
+    .option("--dry-run", "Preview changes without writing files", false)
+    .option("--overwrite", "Overwrite existing files", false)
+    .option("--verbose", "Show verbose output", false)
+    .option("--yes", "Non-interactive mode", false)
+    .option("--cwd <path>", "Run command against a target project directory")
+    .action((agent, options) => runAddCommand(agent, options));

package/dist/commands/info.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const infoCommand: Command;

package/dist/commands/info.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infoCommand = void 0;
+const commander_1 = require("commander");
+const registry_js_1 = require("../lib/registry.js");
+async function runInfo(agentName, options) {
+    const cwd = process.cwd();
+    const registryBase = (0, registry_js_1.resolveRegistrySource)(options.registry, cwd);
+    const item = await (0, registry_js_1.loadRegistryItem)(agentName, registryBase);
+    console.log(`\n${item.title ?? item.name}`);
+    console.log(`${item.description}`);
+    console.log(`Type: ${item.type}`);
+    if (item.categories?.length) {
+        console.log(`Categories: ${item.categories.join(", ")}`);
+    }
+    if (item.dependencies?.length) {
+        console.log(`Dependencies: ${item.dependencies.join(", ")}`);
+    }
+    if (item.envVars && Object.keys(item.envVars).length > 0) {
+        console.log(`Env vars: ${Object.keys(item.envVars).join(", ")}`);
+    }
+    console.log(`Files: ${item.files.length}`);
+    for (const file of item.files) {
+        console.log(`  - ${file.target ?? file.path}`);
+    }
+    console.log("");
+}
+exports.infoCommand = new commander_1.Command("info")
+    .description("Show details for a specific agent")
+    .argument("<agent>", "Agent name")
+    .option("-r, --registry <path|url>", "Registry path or URL")
+    .action(runInfo);

package/dist/commands/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const listCommand: Command;

package/dist/commands/list.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = void 0;
+const commander_1 = require("commander");
+const registry_js_1 = require("../lib/registry.js");
+async function runList(options) {
+    const cwd = process.cwd();
+    const registryBase = (0, registry_js_1.resolveRegistrySource)(options.registry, cwd);
+    const index = await (0, registry_js_1.loadRegistryIndex)(registryBase);
+    console.log(`\nAvailable agents in ${index.name}:\n`);
+    for (const item of index.items) {
+        const categories = item.categories?.length
+            ? ` (${item.categories.join(", ")})`
+            : "";
+        console.log(`- ${item.name}${categories}`);
+        console.log(`  ${item.description}`);
+    }
+    console.log("");
+}
+exports.listCommand = new commander_1.Command("list")
+    .description("List available agents from registry")
+    .option("-r, --registry <path|url>", "Registry path or URL")
+    .action(runList);

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const REGISTRY_SCHEMA_VERSION = 1;

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRY_SCHEMA_VERSION = void 0;
+exports.REGISTRY_SCHEMA_VERSION = 1;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const add_js_1 = require("./commands/add.js");
+const info_js_1 = require("./commands/info.js");
+const list_js_1 = require("./commands/list.js");
+const program = new commander_1.Command();
+program
+    .name("agentcn")
+    .description("Install reusable AI agents into your project")
+    .version("0.1.0");
+program.addCommand(add_js_1.addCommand);
+program.addCommand(list_js_1.listCommand);
+program.addCommand(info_js_1.infoCommand);
+program.parse();

package/dist/lib/config.d.ts

@@ -0,0 +1,10 @@
+export declare function mergeEnvContent(existing: string, envVars: Record<string, string>): {
+    content: string;
+    added: string[];
+};
+export declare function mergeEnvExample(cwd: string, envVars: Record<string, string>, options: {
+    dryRun: boolean;
+}): string[];
+export declare function updateTsconfigPaths(cwd: string, options: {
+    dryRun: boolean;
+}): boolean;

package/dist/lib/config.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeEnvContent = mergeEnvContent;
+exports.mergeEnvExample = mergeEnvExample;
+exports.updateTsconfigPaths = updateTsconfigPaths;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const path_exists_1 = require("path-exists");
+function parseEnvKeys(content) {
+    const keys = new Set();
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const match = /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(trimmed);
+        if (match)
+            keys.add(match[1]);
+    }
+    return keys;
+}
+function mergeEnvContent(existing, envVars) {
+    const existingKeys = parseEnvKeys(existing);
+    const additions = [];
+    const added = [];
+    for (const [key, value] of Object.entries(envVars)) {
+        if (!existingKeys.has(key)) {
+            additions.push(`# Required for agent\n${key}=${value}`);
+            added.push(key);
+        }
+    }
+    if (additions.length === 0)
+        return { content: existing, added };
+    const prefix = existing.trim().length > 0 ? `${existing.trimEnd()}\n\n` : "";
+    return { content: `${prefix}${additions.join("\n")}\n`, added };
+}
+function mergeEnvExample(cwd, envVars, options) {
+    const envPath = path.join(cwd, ".env.example");
+    const existing = (0, path_exists_1.pathExistsSync)(envPath) ? fs.readFileSync(envPath, "utf-8") : "";
+    const { content, added } = mergeEnvContent(existing, envVars);
+    if (!options.dryRun && content !== existing) {
+        fs.writeFileSync(envPath, content, "utf-8");
+    }
+    return added;
+}
+function updateTsconfigPaths(cwd, options) {
+    const tsconfigPath = path.join(cwd, "tsconfig.json");
+    if (!(0, path_exists_1.pathExistsSync)(tsconfigPath))
+        return false;
+    try {
+        const content = fs.readFileSync(tsconfigPath, "utf-8");
+        const config = JSON.parse(content);
+        const compilerOptions = config.compilerOptions ?? {};
+        const paths = compilerOptions.paths ?? {};
+        let changed = false;
+        if (!paths["@/agents/*"]) {
+            paths["@/agents/*"] = ["./ai/agents/*"];
+            changed = true;
+        }
+        if (!paths["@/tools/*"]) {
+            paths["@/tools/*"] = ["./ai/tools/*"];
+            changed = true;
+        }
+        compilerOptions.paths = paths;
+        config.compilerOptions = compilerOptions;
+        if (changed && !options.dryRun) {
+            fs.writeFileSync(tsconfigPath, JSON.stringify(config, null, 2), "utf-8");
+        }
+        return changed;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/deps.d.ts

@@ -0,0 +1,6 @@
+export declare function getExecErrorOutput(error: unknown): string;
+export declare function detectPackageManager(cwd: string): "npm" | "pnpm" | "yarn";
+export declare function installDependencies(cwd: string, dependencies: string[] | undefined, options: {
+    dryRun: boolean;
+    verbose: boolean;
+}): string[];