@agentforge-ai/cli 0.3.2 → 0.4.1

package/dist/index.js

@@ -19,15 +19,25 @@ async function createProject(projectName, options) {
   console.log(`
 \u{1F528} Creating AgentForge project: ${projectName}
 `);
-  const templateDir = path.resolve(
-    __dirname,
-    "..",
-    // from dist/commands to dist
-    "templates",
-    options.template
-  );
-  if (!await fs.pathExists(templateDir)) {
+  const searchDirs = [
+    path.resolve(__dirname, options.template),
+    // dist/default (built)
+    path.resolve(__dirname, "..", "templates", options.template),
+    // packages/cli/templates/default (dev)
+    path.resolve(__dirname, "..", "..", "templates", options.template)
+    // fallback
+  ];
+  let templateDir = "";
+  for (const dir of searchDirs) {
+    if (await fs.pathExists(path.join(dir, "package.json"))) {
+      templateDir = dir;
+      break;
+    }
+  }
+  if (!templateDir) {
     console.error(`Error: Template "${options.template}" not found.`);
+    console.error(`Searched in:`);
+    searchDirs.forEach((d) => console.error(`  - ${d}`));
     process.exit(1);
   }
   await fs.copy(templateDir, targetDir);
@@ -37,6 +47,12 @@ async function createProject(projectName, options) {
     pkg2.name = projectName;
     await fs.writeJson(pkgPath, pkg2, { spaces: 2 });
   }
+  const dashPkgPath = path.join(targetDir, "dashboard", "package.json");
+  if (await fs.pathExists(dashPkgPath)) {
+    const dashPkg = await fs.readJson(dashPkgPath);
+    dashPkg.name = `${projectName}-dashboard`;
+    await fs.writeJson(dashPkgPath, dashPkg, { spaces: 2 });
+  }
   console.log(`  \u2705 Project scaffolded at ./${projectName}`);
   console.log(`
 \u{1F4E6} Installing dependencies...
@@ -54,12 +70,58 @@ async function createProject(projectName, options) {
   \u26A0\uFE0F  Could not install dependencies. Run "cd ${projectName} && pnpm install" manually.`
     );
   }
+  const dashDir = path.join(targetDir, "dashboard");
+  if (await fs.pathExists(dashDir)) {
+    console.log(`
+\u{1F4E6} Installing dashboard dependencies...
+`);
+    try {
+      execSync("pnpm install", {
+        cwd: dashDir,
+        stdio: "inherit"
+      });
+      console.log(`
+  \u2705 Dashboard dependencies installed`);
+    } catch {
+      console.warn(
+        `
+  \u26A0\uFE0F  Could not install dashboard dependencies. Run "cd ${projectName}/dashboard && pnpm install" manually.`
+      );
+    }
+  }
+  console.log(`
+\u26A1 Initializing Convex...
+`);
+  try {
+    execSync("npx convex dev --once", {
+      cwd: targetDir,
+      stdio: "inherit"
+    });
+    console.log(`
+  \u2705 Convex initialized`);
+  } catch {
+    console.warn(
+      `
+  \u26A0\uFE0F  Convex initialization skipped. Run "npx convex dev" to set up your backend.`
+    );
+  }
   console.log(`
 \u{1F389} AgentForge project "${projectName}" created successfully!
 
 Next steps:
   cd ${projectName}
-  agentforge run
+
+  # Start the Convex backend
+  npx convex dev
+
+  # In another terminal, launch the dashboard
+  agentforge dashboard
+
+  # Or chat with your agent from the CLI
+  agentforge chat
+
+  # Check system status
+  agentforge status
 
 Documentation: https://github.com/Agentic-Engineering-Agency/agentforge
 `);
@@ -232,6 +294,1496 @@ async function deployProject(options) {
   }
 }
 
+// src/lib/convex-client.ts
+import { ConvexHttpClient } from "convex/browser";
+import fs4 from "fs-extra";
+import path4 from "path";
+function getConvexUrl() {
+  const cwd = process.cwd();
+  const envFiles = [".env.local", ".env", ".env.production"];
+  for (const envFile of envFiles) {
+    const envPath = path4.join(cwd, envFile);
+    if (fs4.existsSync(envPath)) {
+      const content = fs4.readFileSync(envPath, "utf-8");
+      const match = content.match(/CONVEX_URL\s*=\s*(.+)/);
+      if (match) {
+        return match[1].trim().replace(/["']/g, "");
+      }
+    }
+  }
+  const convexEnv = path4.join(cwd, ".convex", "deployment.json");
+  if (fs4.existsSync(convexEnv)) {
+    try {
+      const data = JSON.parse(fs4.readFileSync(convexEnv, "utf-8"));
+      if (data.url) return data.url;
+    } catch {
+    }
+  }
+  throw new Error(
+    "CONVEX_URL not found. Run `npx convex dev` first, or set CONVEX_URL in your .env file."
+  );
+}
+function createClient() {
+  const url = getConvexUrl();
+  return new ConvexHttpClient(url);
+}
+async function safeCall(fn, errorMessage) {
+  try {
+    return await fn();
+  } catch (error2) {
+    if (error2.message?.includes("CONVEX_URL not found")) {
+      console.error("\n\u274C Not connected to Convex.");
+      console.error("   Run `npx convex dev` in your project directory first.\n");
+    } else if (error2.message?.includes("fetch failed") || error2.message?.includes("ECONNREFUSED")) {
+      console.error("\n\u274C Cannot reach Convex deployment.");
+      console.error("   Make sure `npx convex dev` is running.\n");
+    } else {
+      console.error(`
+\u274C ${errorMessage}`);
+      console.error(`   ${error2.message}
+`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/lib/display.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+function success(msg) {
+  console.log(`${colors.green}\u2714${colors.reset} ${msg}`);
+}
+function error(msg) {
+  console.error(`${colors.red}\u2716${colors.reset} ${msg}`);
+}
+function info(msg) {
+  console.log(`${colors.blue}\u2139${colors.reset} ${msg}`);
+}
+function header(title) {
+  console.log(`
+${colors.bold}${colors.cyan}${title}${colors.reset}
+`);
+}
+function dim(msg) {
+  console.log(`${colors.dim}${msg}${colors.reset}`);
+}
+function table(data, columns) {
+  if (data.length === 0) {
+    dim("  (no items)");
+    return;
+  }
+  const cols = columns ?? Object.keys(data[0]);
+  const widths = {};
+  for (const col of cols) {
+    widths[col] = Math.max(
+      col.length,
+      ...data.map((row) => String(row[col] ?? "").length)
+    );
+  }
+  const headerRow = cols.map((c) => c.toUpperCase().padEnd(widths[c])).join("  ");
+  console.log(`  ${colors.bold}${headerRow}${colors.reset}`);
+  console.log(`  ${cols.map((c) => "\u2500".repeat(widths[c])).join("\u2500\u2500")}`);
+  for (const row of data) {
+    const line = cols.map((c) => String(row[c] ?? "").padEnd(widths[c])).join("  ");
+    console.log(`  ${line}`);
+  }
+  console.log();
+}
+function details(data) {
+  const maxKey = Math.max(...Object.keys(data).map((k) => k.length));
+  for (const [key, value] of Object.entries(data)) {
+    const label = `${colors.dim}${key.padEnd(maxKey)}${colors.reset}`;
+    console.log(`  ${label}  ${value}`);
+  }
+  console.log();
+}
+function formatDate(ts) {
+  return new Date(ts).toLocaleString();
+}
+
+// src/commands/agents.ts
+import readline from "readline";
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => rl.question(question, (ans) => {
+    rl.close();
+    resolve2(ans.trim());
+  }));
+}
+function registerAgentsCommand(program2) {
+  const agents = program2.command("agents").description("Manage agents");
+  agents.command("list").description("List all agents").option("--active", "Show only active agents").option("--json", "Output as JSON").action(async (opts) => {
+    const client = createClient();
+    const result = await safeCall(
+      () => client.query("agents:list", {}),
+      "Failed to list agents"
+    );
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Agents");
+    if (!result || result.length === 0) {
+      info("No agents found. Create one with: agentforge agents create");
+      return;
+    }
+    const filtered = opts.active ? result.filter((a) => a.isActive) : result;
+    table(
+      filtered.map((a) => ({
+        ID: a.id,
+        Name: a.name,
+        Model: a.model,
+        Provider: a.provider || "openai",
+        Active: a.isActive ? "\u2714" : "\u2716",
+        Created: formatDate(a.createdAt)
+      }))
+    );
+  });
+  agents.command("create").description("Create a new agent (interactive)").option("--name <name>", "Agent name").option("--model <model>", "Model identifier (e.g., openai:gpt-4o-mini)").option("--instructions <text>", "System instructions").action(async (opts) => {
+    const name = opts.name || await prompt("Agent name: ");
+    const model = opts.model || await prompt("Model (e.g., openai:gpt-4o-mini): ");
+    const instructions = opts.instructions || await prompt("Instructions: ");
+    if (!name || !model || !instructions) {
+      error("Name, model, and instructions are required.");
+      process.exit(1);
+    }
+    const provider = model.includes(":") ? model.split(":")[0] : "openai";
+    const agentId = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const client = createClient();
+    await safeCall(
+      () => client.mutation("agents:create", {
+        id: agentId,
+        name,
+        instructions,
+        model,
+        provider,
+        isActive: true
+      }),
+      "Failed to create agent"
+    );
+    success(`Agent "${name}" created with ID: ${agentId}`);
+  });
+  agents.command("inspect").argument("<id>", "Agent ID").description("Show detailed agent information").action(async (id) => {
+    const client = createClient();
+    const agent = await safeCall(
+      () => client.query("agents:getByAgentId", { id }),
+      "Failed to fetch agent"
+    );
+    if (!agent) {
+      error(`Agent "${id}" not found.`);
+      process.exit(1);
+    }
+    header(`Agent: ${agent.name}`);
+    const a = agent;
+    details({
+      "ID": a.id,
+      "Name": a.name,
+      "Model": a.model,
+      "Provider": a.provider || "openai",
+      "Active": a.isActive ? "Yes" : "No",
+      "Temperature": a.temperature ?? "default",
+      "Max Tokens": a.maxTokens ?? "default",
+      "Created": formatDate(a.createdAt),
+      "Updated": formatDate(a.updatedAt)
+    });
+    if (a.description) info(`Description: ${a.description}`);
+    console.log(`  Instructions:
+  ${a.instructions.split("\n").join("\n  ")}
+`);
+  });
+  agents.command("edit").argument("<id>", "Agent ID").option("--name <name>", "New name").option("--model <model>", "New model").option("--instructions <text>", "New instructions").description("Edit an agent").action(async (id, opts) => {
+    const client = createClient();
+    const agent = await safeCall(
+      () => client.query("agents:getByAgentId", { id }),
+      "Failed to fetch agent"
+    );
+    if (!agent) {
+      error(`Agent "${id}" not found.`);
+      process.exit(1);
+    }
+    const updates = {};
+    if (opts.name) updates.name = opts.name;
+    if (opts.model) {
+      updates.model = opts.model;
+      updates.provider = opts.model.includes(":") ? opts.model.split(":")[0] : "openai";
+    }
+    if (opts.instructions) updates.instructions = opts.instructions;
+    if (Object.keys(updates).length === 0) {
+      const a = agent;
+      const name = await prompt(`Name [${a.name}]: `);
+      const model = await prompt(`Model [${a.model}]: `);
+      const instr = await prompt(`Instructions [keep current]: `);
+      if (name) updates.name = name;
+      if (model) {
+        updates.model = model;
+        updates.provider = model.includes(":") ? model.split(":")[0] : "openai";
+      }
+      if (instr) updates.instructions = instr;
+    }
+    if (Object.keys(updates).length === 0) {
+      info("No changes made.");
+      return;
+    }
+    await safeCall(
+      () => client.mutation("agents:update", { _id: agent._id, ...updates }),
+      "Failed to update agent"
+    );
+    success(`Agent "${id}" updated.`);
+  });
+  agents.command("delete").argument("<id>", "Agent ID").option("-f, --force", "Skip confirmation").description("Delete an agent").action(async (id, opts) => {
+    if (!opts.force) {
+      const confirm = await prompt(`Delete agent "${id}"? (y/N): `);
+      if (confirm.toLowerCase() !== "y") {
+        info("Cancelled.");
+        return;
+      }
+    }
+    const client = createClient();
+    const agent = await safeCall(
+      () => client.query("agents:getByAgentId", { id }),
+      "Failed to fetch agent"
+    );
+    if (!agent) {
+      error(`Agent "${id}" not found.`);
+      process.exit(1);
+    }
+    await safeCall(
+      () => client.mutation("agents:remove", { _id: agent._id }),
+      "Failed to delete agent"
+    );
+    success(`Agent "${id}" deleted.`);
+  });
+  agents.command("enable").argument("<id>", "Agent ID").description("Enable an agent").action(async (id) => {
+    const client = createClient();
+    const agent = await safeCall(() => client.query("agents:getByAgentId", { id }), "Failed to fetch agent");
+    if (!agent) {
+      error(`Agent "${id}" not found.`);
+      process.exit(1);
+    }
+    await safeCall(() => client.mutation("agents:update", { _id: agent._id, isActive: true }), "Failed");
+    success(`Agent "${id}" enabled.`);
+  });
+  agents.command("disable").argument("<id>", "Agent ID").description("Disable an agent").action(async (id) => {
+    const client = createClient();
+    const agent = await safeCall(() => client.query("agents:getByAgentId", { id }), "Failed to fetch agent");
+    if (!agent) {
+      error(`Agent "${id}" not found.`);
+      process.exit(1);
+    }
+    await safeCall(() => client.mutation("agents:update", { _id: agent._id, isActive: false }), "Failed");
+    success(`Agent "${id}" disabled.`);
+  });
+}
+
+// src/commands/chat.ts
+import readline2 from "readline";
+function registerChatCommand(program2) {
+  program2.command("chat").argument("[agent-id]", "Agent ID to chat with").option("-s, --session <id>", "Resume an existing session").description("Start an interactive chat session with an agent").action(async (agentId, opts) => {
+    const client = createClient();
+    if (!agentId && !opts.session) {
+      const agents = await safeCall(() => client.query("agents:list", {}), "Failed to list agents");
+      if (!agents || agents.length === 0) {
+        error("No agents found. Create one first: agentforge agents create");
+        process.exit(1);
+      }
+      header("Available Agents");
+      agents.forEach((a2, i) => {
+        console.log(`  ${colors.cyan}${i + 1}.${colors.reset} ${a2.name} ${colors.dim}(${a2.id})${colors.reset}`);
+      });
+      console.log();
+      const rl2 = readline2.createInterface({ input: process.stdin, output: process.stdout });
+      const choice = await new Promise((r) => rl2.question("Select agent (number or ID): ", (a2) => {
+        rl2.close();
+        r(a2.trim());
+      }));
+      const idx = parseInt(choice) - 1;
+      agentId = idx >= 0 && idx < agents.length ? agents[idx].id : choice;
+    }
+    const agent = await safeCall(() => client.query("agents:getByAgentId", { id: agentId }), "Failed to fetch agent");
+    if (!agent) {
+      error(`Agent "${agentId}" not found.`);
+      process.exit(1);
+    }
+    const a = agent;
+    header(`Chat with ${a.name}`);
+    dim(`  Model: ${a.model} | Provider: ${a.provider || "openai"}`);
+    dim(`  Type "exit" or "quit" to end. "/new" for new thread. "/history" for messages.`);
+    console.log();
+    let threadId = await safeCall(
+      () => client.mutation("threads:create", { agentId: a.id, status: "active" }),
+      "Failed to create thread"
+    );
+    const history = [];
+    const rl = readline2.createInterface({ input: process.stdin, output: process.stdout, prompt: `${colors.green}You${colors.reset} > ` });
+    rl.prompt();
+    rl.on("line", async (line) => {
+      const input = line.trim();
+      if (!input) {
+        rl.prompt();
+        return;
+      }
+      if (input === "exit" || input === "quit") {
+        success("Session ended. Goodbye!");
+        process.exit(0);
+      }
+      if (input === "/new") {
+        threadId = await safeCall(() => client.mutation("threads:create", { agentId: a.id, status: "active" }), "Failed");
+        history.length = 0;
+        info("New thread started.");
+        rl.prompt();
+        return;
+      }
+      if (input === "/history") {
+        history.forEach((m) => {
+          const prefix = m.role === "user" ? `${colors.green}You${colors.reset}` : `${colors.cyan}${a.name}${colors.reset}`;
+          console.log(`  ${prefix}: ${m.content}`);
+        });
+        if (history.length === 0) dim("  (no messages yet)");
+        console.log();
+        rl.prompt();
+        return;
+      }
+      history.push({ role: "user", content: input });
+      await safeCall(() => client.mutation("messages:send", { threadId, role: "user", content: input }), "Failed to send");
+      process.stdout.write(`${colors.cyan}${a.name}${colors.reset} > `);
+      try {
+        const response = await safeCall(
+          () => client.action("mastraIntegration:generateResponse", { agentId: a.id, threadId, message: input }),
+          "Failed to get response"
+        );
+        const text = response?.text || response?.content || String(response);
+        console.log(text);
+        history.push({ role: "assistant", content: text });
+      } catch {
+        console.log(`${colors.yellow}[Configure your LLM API key in .env to get responses]${colors.reset}`);
+      }
+      console.log();
+      rl.prompt();
+    });
+    rl.on("close", () => {
+      console.log();
+      info("Session ended.");
+      process.exit(0);
+    });
+  });
+}
+
+// src/commands/sessions.ts
+function registerSessionsCommand(program2) {
+  const sessions = program2.command("sessions").description("Manage sessions");
+  sessions.command("list").option("--status <status>", "Filter by status (active, ended)").option("--json", "Output as JSON").description("List all sessions").action(async (opts) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("sessions:list", {}), "Failed to list sessions");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Sessions");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No sessions found.");
+      return;
+    }
+    const filtered = opts.status ? items.filter((s) => s.status === opts.status) : items;
+    table(filtered.map((s) => ({
+      ID: s._id?.slice(-8) || "N/A",
+      Name: s.name || "Unnamed",
+      Agent: s.agentId,
+      Status: s.status,
+      Started: formatDate(s.startedAt),
+      "Last Activity": formatDate(s.lastActivityAt)
+    })));
+  });
+  sessions.command("inspect").argument("<id>", "Session ID").description("Show session details").action(async (id) => {
+    const client = createClient();
+    const session = await safeCall(() => client.query("sessions:getById", { id }), "Failed to fetch session");
+    if (!session) {
+      error(`Session "${id}" not found.`);
+      process.exit(1);
+    }
+    const s = session;
+    header(`Session: ${s.name || "Unnamed"}`);
+    details({ ID: s._id, Name: s.name, Agent: s.agentId, Status: s.status, Started: formatDate(s.startedAt), "Last Activity": formatDate(s.lastActivityAt) });
+  });
+  sessions.command("end").argument("<id>", "Session ID").description("End an active session").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("sessions:update", { _id: id, status: "ended" }), "Failed to end session");
+    success(`Session "${id}" ended.`);
+  });
+}
+function registerThreadsCommand(program2) {
+  const threads = program2.command("threads").description("Manage conversation threads");
+  threads.command("list").option("--agent <id>", "Filter by agent ID").option("--json", "Output as JSON").description("List all threads").action(async (opts) => {
+    const client = createClient();
+    const args = opts.agent ? { agentId: opts.agent } : {};
+    const result = await safeCall(() => client.query("threads:list", args), "Failed to list threads");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Threads");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No threads found.");
+      return;
+    }
+    table(items.map((t) => ({
+      ID: t._id?.slice(-8) || "N/A",
+      Name: t.name || "Unnamed",
+      Agent: t.agentId,
+      Status: t.status,
+      Created: formatDate(t.createdAt)
+    })));
+  });
+  threads.command("inspect").argument("<id>", "Thread ID").description("Show thread messages").action(async (id) => {
+    const client = createClient();
+    const messages = await safeCall(() => client.query("messages:listByThread", { threadId: id }), "Failed to fetch messages");
+    header(`Thread: ${id}`);
+    const items = messages || [];
+    if (items.length === 0) {
+      info("No messages in this thread.");
+      return;
+    }
+    items.forEach((m) => {
+      const role = m.role === "user" ? "\x1B[32mUser\x1B[0m" : m.role === "assistant" ? "\x1B[36mAssistant\x1B[0m" : `\x1B[33m${m.role}\x1B[0m`;
+      console.log(`  ${role}: ${m.content}`);
+    });
+    console.log();
+  });
+  threads.command("delete").argument("<id>", "Thread ID").description("Delete a thread and its messages").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("threads:remove", { _id: id }), "Failed to delete thread");
+    success(`Thread "${id}" deleted.`);
+  });
+}
+
+// src/commands/skills.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+import readline3 from "readline";
+function prompt2(q) {
+  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function registerSkillsCommand(program2) {
+  const skills = program2.command("skills").description("Manage agent skills");
+  skills.command("list").option("--installed", "Show only installed skills").option("--json", "Output as JSON").description("List all skills").action(async (opts) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("skills:list", {}), "Failed to list skills");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Skills");
+    const localSkills = [];
+    const skillsDir = path5.join(process.cwd(), "skills");
+    if (fs5.existsSync(skillsDir)) {
+      const dirs = fs5.readdirSync(skillsDir).filter((d) => fs5.statSync(path5.join(skillsDir, d)).isDirectory());
+      localSkills.push(...dirs);
+    }
+    const items = result || [];
+    if (items.length === 0 && localSkills.length === 0) {
+      info("No skills found. Install one with: agentforge skills install <name>");
+      info("Or create one with: agentforge skills create");
+      return;
+    }
+    if (localSkills.length > 0) {
+      dim("  Local Skills:");
+      localSkills.forEach((s) => {
+        const configPath = path5.join(skillsDir, s, "config.json");
+        let desc = "";
+        if (fs5.existsSync(configPath)) {
+          try {
+            desc = JSON.parse(fs5.readFileSync(configPath, "utf-8")).description || "";
+          } catch {
+          }
+        }
+        console.log(`  ${colors.cyan}\u25CF${colors.reset} ${s} ${colors.dim}${desc}${colors.reset}`);
+      });
+      console.log();
+    }
+    if (items.length > 0) {
+      const filtered = opts.installed ? items.filter((s) => s.isInstalled) : items;
+      table(filtered.map((s) => ({
+        Name: s.name,
+        Category: s.category,
+        Version: s.version,
+        Installed: s.isInstalled ? "\u2714" : "\u2716",
+        Agent: s.agentId || "all"
+      })));
+    }
+  });
+  skills.command("create").description("Create a new skill (interactive)").option("--name <name>", "Skill name").option("--description <desc>", "Skill description").option("--category <cat>", "Category (utility, web, file, data, integration, ai, custom)").action(async (opts) => {
+    const name = opts.name || await prompt2("Skill name (kebab-case): ");
+    const description = opts.description || await prompt2("Description: ");
+    const category = opts.category || await prompt2("Category (utility/web/file/data/integration/ai/custom): ") || "custom";
+    if (!name) {
+      error("Skill name is required.");
+      process.exit(1);
+    }
+    const skillDir = path5.join(process.cwd(), "skills", name);
+    if (fs5.existsSync(skillDir)) {
+      error(`Skill "${name}" already exists at ${skillDir}`);
+      process.exit(1);
+    }
+    fs5.mkdirSync(skillDir, { recursive: true });
+    fs5.writeFileSync(path5.join(skillDir, "config.json"), JSON.stringify({
+      name,
+      version: "1.0.0",
+      description,
+      category,
+      author: "User",
+      tools: [name],
+      dependencies: [],
+      agentInstructions: `You have access to the ${name} skill. ${description}`
+    }, null, 2));
+    fs5.writeFileSync(path5.join(skillDir, "index.ts"), `import { z } from 'zod';
+
+/**
+ * ${name} \u2014 AgentForge Skill
+ * ${description}
+ */
+export const tools = [
+  {
+    name: '${name}',
+    description: '${description}',
+    inputSchema: z.object({
+      input: z.string().describe('Input for ${name}'),
+    }),
+    outputSchema: z.object({
+      result: z.string(),
+      success: z.boolean(),
+    }),
+    handler: async (params: { input: string }) => {
+      // TODO: Implement your skill logic here
+      return { result: \`Processed: \${params.input}\`, success: true };
+    },
+  },
+];
+
+export default { tools };
+`);
+    fs5.writeFileSync(path5.join(skillDir, "SKILL.md"), `# ${name}
+
+${description}
+
+## Usage
+
+Ask your agent: "Use the ${name} tool to [your request]"
+
+## Configuration
+
+Edit \`skills/${name}/config.json\` to customize.
+`);
+    success(`Skill "${name}" created at skills/${name}/`);
+    info("Files created: index.ts, config.json, SKILL.md");
+    info(`Edit skills/${name}/index.ts to implement your tool logic.`);
+  });
+  skills.command("install").argument("<name>", "Skill name to install").description("Install a skill").action(async (name) => {
+    const client = createClient();
+    await safeCall(
+      () => client.mutation("skills:create", {
+        name,
+        category: "custom",
+        version: "1.0.0",
+        isInstalled: true
+      }),
+      "Failed to install skill"
+    );
+    success(`Skill "${name}" installed.`);
+  });
+  skills.command("remove").argument("<name>", "Skill name to remove").description("Remove a skill").action(async (name) => {
+    const skillDir = path5.join(process.cwd(), "skills", name);
+    if (fs5.existsSync(skillDir)) {
+      const confirm = await prompt2(`Remove skill "${name}" and delete files? (y/N): `);
+      if (confirm.toLowerCase() === "y") {
+        fs5.removeSync(skillDir);
+        success(`Skill "${name}" removed from disk.`);
+      }
+    }
+    const client = createClient();
+    try {
+      const skills2 = await client.query("skills:list", {});
+      const skill = skills2.find((s) => s.name === name);
+      if (skill) {
+        await client.mutation("skills:remove", { _id: skill._id });
+        success(`Skill "${name}" removed from database.`);
+      }
+    } catch {
+    }
+  });
+  skills.command("search").argument("<query>", "Search query").description("Search available skills").action(async (query) => {
+    header("Skill Search Results");
+    const examples = [
+      { name: "web-search", desc: "Search the web for information", cat: "web" },
+      { name: "calculator", desc: "Evaluate mathematical expressions", cat: "utility" },
+      { name: "file-reader", desc: "Read file contents", cat: "file" },
+      { name: "http-request", desc: "Make HTTP requests", cat: "web" },
+      { name: "json-transformer", desc: "Transform JSON data", cat: "data" },
+      { name: "text-summarizer", desc: "Summarize text into key points", cat: "ai" },
+      { name: "csv-parser", desc: "Parse CSV into structured JSON", cat: "data" }
+    ];
+    const q = query.toLowerCase();
+    const matches = examples.filter((e) => e.name.includes(q) || e.desc.toLowerCase().includes(q) || e.cat.includes(q));
+    if (matches.length === 0) {
+      info(`No skills matching "${query}". Try: agentforge skills create`);
+      return;
+    }
+    table(matches.map((e) => ({ Name: e.name, Description: e.desc, Category: e.cat })));
+    info("Install with: agentforge skills install <name>");
+    info("Or see examples: check skills/skill-creator/SKILL.md");
+  });
+}
+
+// src/commands/cron.ts
+import readline4 from "readline";
+function prompt3(q) {
+  const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function registerCronCommand(program2) {
+  const cron = program2.command("cron").description("Manage cron jobs");
+  cron.command("list").option("--json", "Output as JSON").description("List all cron jobs").action(async (opts) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("cronJobs:list", {}), "Failed to list cron jobs");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Cron Jobs");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No cron jobs. Create one with: agentforge cron create");
+      return;
+    }
+    table(items.map((c) => ({
+      ID: c._id?.slice(-8) || "N/A",
+      Name: c.name,
+      Schedule: c.schedule,
+      Agent: c.agentId,
+      Enabled: c.isEnabled ? "\u2714" : "\u2716",
+      "Last Run": c.lastRunAt ? formatDate(c.lastRunAt) : "Never",
+      "Next Run": c.nextRunAt ? formatDate(c.nextRunAt) : "N/A"
+    })));
+  });
+  cron.command("create").description("Create a new cron job (interactive)").option("--name <name>", "Job name").option("--schedule <cron>", "Cron expression").option("--agent <id>", "Agent ID").option("--action <action>", "Action to execute").action(async (opts) => {
+    const name = opts.name || await prompt3("Job name: ");
+    const schedule = opts.schedule || await prompt3('Cron schedule (e.g., "0 */5 * * * *" for every 5 min): ');
+    const agentId = opts.agent || await prompt3("Agent ID: ");
+    const action = opts.action || await prompt3("Action (message to send to agent): ");
+    if (!name || !schedule || !agentId || !action) {
+      error("All fields are required.");
+      process.exit(1);
+    }
+    const client = createClient();
+    await safeCall(
+      () => client.mutation("cronJobs:create", { name, schedule, agentId, action, isEnabled: true }),
+      "Failed to create cron job"
+    );
+    success(`Cron job "${name}" created.`);
+  });
+  cron.command("delete").argument("<id>", "Cron job ID").description("Delete a cron job").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("cronJobs:remove", { _id: id }), "Failed to delete");
+    success(`Cron job "${id}" deleted.`);
+  });
+  cron.command("enable").argument("<id>", "Cron job ID").description("Enable a cron job").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("cronJobs:update", { _id: id, isEnabled: true }), "Failed");
+    success(`Cron job "${id}" enabled.`);
+  });
+  cron.command("disable").argument("<id>", "Cron job ID").description("Disable a cron job").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("cronJobs:update", { _id: id, isEnabled: false }), "Failed");
+    success(`Cron job "${id}" disabled.`);
+  });
+}
+
+// src/commands/mcp.ts
+import readline5 from "readline";
+function prompt4(q) {
+  const rl = readline5.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function registerMcpCommand(program2) {
+  const mcp = program2.command("mcp").description("Manage MCP connections");
+  mcp.command("list").option("--json", "Output as JSON").description("List all MCP connections").action(async (opts) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("mcpConnections:list", {}), "Failed to list connections");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("MCP Connections");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No connections. Add one with: agentforge mcp add");
+      return;
+    }
+    table(items.map((c) => ({
+      ID: c._id?.slice(-8) || "N/A",
+      Name: c.name,
+      Type: c.type,
+      Endpoint: c.endpoint,
+      Connected: c.isConnected ? "\u2714" : "\u2716",
+      Enabled: c.isEnabled ? "\u2714" : "\u2716"
+    })));
+  });
+  mcp.command("add").description("Add a new MCP connection (interactive)").option("--name <name>", "Connection name").option("--type <type>", "Connection type (stdio, sse, http)").option("--endpoint <url>", "Endpoint URL or command").action(async (opts) => {
+    const name = opts.name || await prompt4("Connection name: ");
+    const type = opts.type || await prompt4("Type (stdio/sse/http): ");
+    const endpoint = opts.endpoint || await prompt4("Endpoint (URL or command): ");
+    if (!name || !type || !endpoint) {
+      error("All fields required.");
+      process.exit(1);
+    }
+    const client = createClient();
+    await safeCall(
+      () => client.mutation("mcpConnections:create", {
+        name,
+        type,
+        endpoint,
+        isConnected: false,
+        isEnabled: true
+      }),
+      "Failed to add connection"
+    );
+    success(`MCP connection "${name}" added.`);
+  });
+  mcp.command("remove").argument("<id>", "Connection ID").description("Remove an MCP connection").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("mcpConnections:remove", { _id: id }), "Failed");
+    success(`Connection "${id}" removed.`);
+  });
+  mcp.command("test").argument("<id>", "Connection ID").description("Test an MCP connection").action(async (id) => {
+    info(`Testing connection "${id}"...`);
+    const client = createClient();
+    const conns = await safeCall(() => client.query("mcpConnections:list", {}), "Failed");
+    const conn = conns.find((c) => c._id === id || c._id?.endsWith(id));
+    if (!conn) {
+      error(`Connection "${id}" not found.`);
+      process.exit(1);
+    }
+    if (conn.type === "http" || conn.type === "sse") {
+      try {
+        const res = await fetch(conn.endpoint, { method: "HEAD", signal: AbortSignal.timeout(5e3) });
+        if (res.ok) {
+          success(`Connection "${conn.name}" is reachable (HTTP ${res.status}).`);
+          await client.mutation("mcpConnections:update", { _id: conn._id, isConnected: true });
+        } else {
+          error(`Connection "${conn.name}" returned HTTP ${res.status}.`);
+        }
+      } catch (e) {
+        error(`Connection "${conn.name}" failed: ${e.message}`);
+      }
+    } else {
+      info(`Connection type "${conn.type}" \u2014 manual verification required.`);
+      info(`Endpoint: ${conn.endpoint}`);
+    }
+  });
+  mcp.command("enable").argument("<id>", "Connection ID").description("Enable a connection").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("mcpConnections:update", { _id: id, isEnabled: true }), "Failed");
+    success(`Connection "${id}" enabled.`);
+  });
+  mcp.command("disable").argument("<id>", "Connection ID").description("Disable a connection").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("mcpConnections:update", { _id: id, isEnabled: false }), "Failed");
+    success(`Connection "${id}" disabled.`);
+  });
+}
+
+// src/commands/files.ts
+import fs6 from "fs-extra";
+import path6 from "path";
+function registerFilesCommand(program2) {
+  const files = program2.command("files").description("Manage files");
+  files.command("list").argument("[folder]", "Folder ID to list files from").option("--json", "Output as JSON").description("List files").action(async (folder, opts) => {
+    const client = createClient();
+    const args = folder ? { folderId: folder } : {};
+    const result = await safeCall(() => client.query("files:list", args), "Failed to list files");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Files");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No files. Upload one with: agentforge files upload <path>");
+      return;
+    }
+    table(items.map((f) => ({
+      ID: f._id?.slice(-8) || "N/A",
+      Name: f.name,
+      Type: f.mimeType,
+      Size: formatSize(f.size),
+      Folder: f.folderId || "root",
+      Created: formatDate(f.createdAt)
+    })));
+  });
+  files.command("upload").argument("<filepath>", "Path to file to upload").option("--folder <id>", "Folder ID to upload to").option("--project <id>", "Project ID to associate with").description("Upload a file").action(async (filepath, opts) => {
+    const absPath = path6.resolve(filepath);
+    if (!fs6.existsSync(absPath)) {
+      error(`File not found: ${absPath}`);
+      process.exit(1);
+    }
+    const stat = fs6.statSync(absPath);
+    const name = path6.basename(absPath);
+    const ext = path6.extname(absPath).toLowerCase();
+    const mimeTypes = {
+      ".txt": "text/plain",
+      ".md": "text/markdown",
+      ".json": "application/json",
+      ".js": "text/javascript",
+      ".ts": "text/typescript",
+      ".py": "text/x-python",
+      ".pdf": "application/pdf",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".csv": "text/csv",
+      ".html": "text/html",
+      ".xml": "text/xml"
+    };
+    const mimeType = mimeTypes[ext] || "application/octet-stream";
+    const client = createClient();
+    await safeCall(
+      () => client.mutation("files:create", {
+        name,
+        mimeType,
+        size: stat.size,
+        folderId: opts.folder,
+        projectId: opts.project
+      }),
+      "Failed to upload file metadata"
+    );
+    success(`File "${name}" registered (${formatSize(stat.size)}, ${mimeType}).`);
+    info("Note: File content storage requires Convex file storage or R2 integration.");
+  });
+  files.command("delete").argument("<id>", "File ID").description("Delete a file").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("files:remove", { _id: id }), "Failed to delete file");
+    success(`File "${id}" deleted.`);
+  });
+  const folders = program2.command("folders").description("Manage folders");
+  folders.command("list").option("--json", "Output as JSON").description("List all folders").action(async (opts) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("folders:list", {}), "Failed to list folders");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Folders");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No folders. Create one with: agentforge folders create <name>");
+      return;
+    }
+    table(items.map((f) => ({
+      ID: f._id?.slice(-8) || "N/A",
+      Name: f.name,
+      Parent: f.parentId || "root",
+      Created: formatDate(f.createdAt)
+    })));
+  });
+  folders.command("create").argument("<name>", "Folder name").option("--parent <id>", "Parent folder ID").description("Create a folder").action(async (name, opts) => {
+    const client = createClient();
+    await safeCall(
+      () => client.mutation("folders:create", { name, parentId: opts.parent }),
+      "Failed to create folder"
+    );
+    success(`Folder "${name}" created.`);
+  });
+  folders.command("delete").argument("<id>", "Folder ID").description("Delete a folder").action(async (id) => {
+    const client = createClient();
+    await safeCall(() => client.mutation("folders:remove", { _id: id }), "Failed to delete folder");
+    success(`Folder "${id}" deleted.`);
+  });
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/commands/projects.ts
+import readline6 from "readline";
+function prompt5(q) {
+  const rl = readline6.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function registerProjectsCommand(program2) {
+  const projects = program2.command("projects").description("Manage projects and workspaces");
+  projects.command("list").option("--json", "Output as JSON").description("List all projects").action(async (opts) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("projects:list", {}), "Failed to list projects");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Projects");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No projects. Create one with: agentforge projects create <name>");
+      return;
+    }
+    table(items.map((p) => ({
+      ID: p._id?.slice(-8) || "N/A",
+      Name: p.name,
+      Status: p.status,
+      Description: (p.description || "").slice(0, 40),
+      Created: formatDate(p.createdAt)
+    })));
+  });
+  projects.command("create").argument("<name>", "Project name").option("-d, --description <desc>", "Project description").description("Create a new project").action(async (name, opts) => {
+    const description = opts.description || await prompt5("Description (optional): ");
+    const client = createClient();
+    await safeCall(
+      () => client.mutation("projects:create", { name, description, status: "active" }),
+      "Failed to create project"
+    );
+    success(`Project "${name}" created.`);
+  });
+  projects.command("inspect").argument("<id>", "Project ID").description("Show project details").action(async (id) => {
+    const client = createClient();
+    const projects2 = await safeCall(() => client.query("projects:list", {}), "Failed");
+    const project = projects2.find((p) => p._id === id || p._id?.endsWith(id));
+    if (!project) {
+      error(`Project "${id}" not found.`);
+      process.exit(1);
+    }
+    header(`Project: ${project.name}`);
+    details({
+      ID: project._id,
+      Name: project.name,
+      Status: project.status,
+      Description: project.description || "N/A",
+      Created: formatDate(project.createdAt),
+      Updated: formatDate(project.updatedAt)
+    });
+  });
+  projects.command("delete").argument("<id>", "Project ID").option("-f, --force", "Skip confirmation").description("Delete a project").action(async (id, opts) => {
+    if (!opts.force) {
+      const confirm = await prompt5(`Delete project "${id}"? (y/N): `);
+      if (confirm.toLowerCase() !== "y") {
+        info("Cancelled.");
+        return;
+      }
+    }
+    const client = createClient();
+    await safeCall(() => client.mutation("projects:remove", { _id: id }), "Failed");
+    success(`Project "${id}" deleted.`);
+  });
+  projects.command("switch").argument("<id>", "Project ID to switch to").description("Set the active project").action(async (id) => {
+    const client = createClient();
+    const projects2 = await safeCall(() => client.query("projects:list", {}), "Failed");
+    const project = projects2.find((p) => p._id === id || p._id?.endsWith(id));
+    if (!project) {
+      error(`Project "${id}" not found.`);
+      process.exit(1);
+    }
+    await safeCall(
+      () => client.mutation("settings:set", { userId: "cli", key: "activeProject", value: project._id }),
+      "Failed to switch project"
+    );
+    success(`Switched to project "${project.name}".`);
+  });
+}
+
+// src/commands/config.ts
+import fs7 from "fs-extra";
+import path7 from "path";
+import readline7 from "readline";
+function prompt6(q) {
+  const rl = readline7.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("Manage configuration");
+  config.command("show").description("Show current configuration").action(async () => {
+    header("Configuration");
+    const cwd = process.cwd();
+    const envFiles = [".env", ".env.local", ".env.production"];
+    for (const envFile of envFiles) {
+      const envPath = path7.join(cwd, envFile);
+      if (fs7.existsSync(envPath)) {
+        console.log(`  ${colors.cyan}${envFile}${colors.reset}`);
+        const content = fs7.readFileSync(envPath, "utf-8");
+        content.split("\n").forEach((line) => {
+          if (line.trim() && !line.startsWith("#")) {
+            const [key, ...rest] = line.split("=");
+            const value = rest.join("=").trim();
+            const masked = key.toLowerCase().includes("key") || key.toLowerCase().includes("secret") || key.toLowerCase().includes("token") ? value.slice(0, 4) + "****" + value.slice(-4) : value;
+            console.log(`    ${colors.dim}${key.trim()}${colors.reset} = ${masked}`);
+          }
+        });
+        console.log();
+      }
+    }
+    const convexDir = path7.join(cwd, ".convex");
+    if (fs7.existsSync(convexDir)) {
+      info("Convex: Configured");
+    } else {
+      info("Convex: Not configured (run `npx convex dev`)");
+    }
+    const skillsDir = path7.join(cwd, "skills");
+    if (fs7.existsSync(skillsDir)) {
+      const skills = fs7.readdirSync(skillsDir).filter((d) => fs7.statSync(path7.join(skillsDir, d)).isDirectory());
+      info(`Skills: ${skills.length} installed (${skills.join(", ")})`);
+    } else {
+      info("Skills: None installed");
+    }
+  });
+  config.command("set").argument("<key>", "Configuration key").argument("<value>", "Configuration value").option("--env <file>", "Environment file to update", ".env.local").description("Set a configuration value").action(async (key, value, opts) => {
+    const envPath = path7.join(process.cwd(), opts.env);
+    let content = "";
+    if (fs7.existsSync(envPath)) {
+      content = fs7.readFileSync(envPath, "utf-8");
+    }
+    const lines = content.split("\n");
+    const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
+    if (idx >= 0) {
+      lines[idx] = `${key}=${value}`;
+    } else {
+      lines.push(`${key}=${value}`);
+    }
+    fs7.writeFileSync(envPath, lines.join("\n"));
+    success(`Set ${key} in ${opts.env}`);
+  });
+  config.command("get").argument("<key>", "Configuration key").description("Get a configuration value").action(async (key) => {
+    const cwd = process.cwd();
+    const envFiles = [".env.local", ".env", ".env.production"];
+    for (const envFile of envFiles) {
+      const envPath = path7.join(cwd, envFile);
+      if (fs7.existsSync(envPath)) {
+        const content = fs7.readFileSync(envPath, "utf-8");
+        const match = content.match(new RegExp(`^${key}=(.+)$`, "m"));
+        if (match) {
+          console.log(match[1].trim());
+          return;
+        }
+      }
+    }
+    error(`Key "${key}" not found in any .env file.`);
+  });
+  config.command("init").description("Initialize configuration for a new project").action(async () => {
+    header("Project Configuration");
+    const convexUrl = await prompt6("Convex URL (from `npx convex dev`): ");
+    const provider = await prompt6("LLM Provider (openai/openrouter/anthropic/google): ") || "openai";
+    const apiKey = await prompt6(`${provider.toUpperCase()} API Key: `);
+    const envContent = [
+      `# AgentForge Configuration`,
+      `CONVEX_URL=${convexUrl}`,
+      ``,
+      `# LLM Provider`,
+      `LLM_PROVIDER=${provider}`
+    ];
+    if (provider === "openai") envContent.push(`OPENAI_API_KEY=${apiKey}`);
+    else if (provider === "openrouter") envContent.push(`OPENROUTER_API_KEY=${apiKey}`);
+    else if (provider === "anthropic") envContent.push(`ANTHROPIC_API_KEY=${apiKey}`);
+    else if (provider === "google") envContent.push(`GOOGLE_API_KEY=${apiKey}`);
+    fs7.writeFileSync(path7.join(process.cwd(), ".env.local"), envContent.join("\n") + "\n");
+    success("Configuration saved to .env.local");
+    info("Run `npx convex dev` to start the Convex backend.");
+  });
+  config.command("provider").argument("<provider>", "LLM provider to configure (openai, openrouter, anthropic, google, xai)").description("Configure an LLM provider").action(async (provider) => {
+    const keyNames = {
+      openai: "OPENAI_API_KEY",
+      openrouter: "OPENROUTER_API_KEY",
+      anthropic: "ANTHROPIC_API_KEY",
+      google: "GOOGLE_API_KEY",
+      xai: "XAI_API_KEY"
+    };
+    const keyName = keyNames[provider.toLowerCase()];
+    if (!keyName) {
+      error(`Unknown provider "${provider}". Supported: ${Object.keys(keyNames).join(", ")}`);
+      process.exit(1);
+    }
+    const apiKey = await prompt6(`${keyName}: `);
+    if (!apiKey) {
+      error("API key is required.");
+      process.exit(1);
+    }
+    const envPath = path7.join(process.cwd(), ".env.local");
+    let content = "";
+    if (fs7.existsSync(envPath)) content = fs7.readFileSync(envPath, "utf-8");
+    const lines = content.split("\n");
+    const idx = lines.findIndex((l) => l.startsWith(`${keyName}=`));
+    if (idx >= 0) lines[idx] = `${keyName}=${apiKey}`;
+    else lines.push(`${keyName}=${apiKey}`);
+    const provIdx = lines.findIndex((l) => l.startsWith("LLM_PROVIDER="));
+    if (provIdx >= 0) lines[provIdx] = `LLM_PROVIDER=${provider}`;
+    else lines.push(`LLM_PROVIDER=${provider}`);
+    fs7.writeFileSync(envPath, lines.join("\n"));
+    success(`Provider "${provider}" configured.`);
+  });
+}
+
+// src/commands/vault.ts
+import readline8 from "readline";
+function prompt7(q) {
+  const rl = readline8.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function promptSecret(q) {
+  return new Promise((resolve2) => {
+    const rl = readline8.createInterface({ input: process.stdin, output: process.stdout });
+    if (process.stdin.isTTY) {
+      process.stdout.write(q);
+      let input = "";
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding("utf-8");
+      const onData = (char) => {
+        if (char === "\n" || char === "\r") {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener("data", onData);
+          console.log();
+          rl.close();
+          resolve2(input);
+        } else if (char === "") {
+          process.exit();
+        } else if (char === "\x7F") {
+          input = input.slice(0, -1);
+          process.stdout.clearLine(0);
+          process.stdout.cursorTo(0);
+          process.stdout.write(q + "*".repeat(input.length));
+        } else {
+          input += char;
+          process.stdout.write("*");
+        }
+      };
+      process.stdin.on("data", onData);
+    } else {
+      rl.question(q, (ans) => {
+        rl.close();
+        resolve2(ans.trim());
+      });
+    }
+  });
+}
+function registerVaultCommand(program2) {
+  const vault = program2.command("vault").description("Manage secrets securely");
+  vault.command("list").option("--json", "Output as JSON").description("List all stored secrets (values hidden)").action(async (opts) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("vault:list", {}), "Failed to list secrets");
+    if (opts.json) {
+      const safe = (result || []).map((s) => ({ ...s, encryptedValue: void 0 }));
+      console.log(JSON.stringify(safe, null, 2));
+      return;
+    }
+    header("Vault \u2014 Stored Secrets");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No secrets stored. Add one with: agentforge vault set <name> <value>");
+      return;
+    }
+    table(items.map((s) => ({
+      Name: s.name,
+      Category: s.category || "general",
+      Provider: s.provider || "N/A",
+      "Last Rotated": s.lastRotatedAt ? formatDate(s.lastRotatedAt) : "Never",
+      Created: formatDate(s.createdAt)
+    })));
+  });
+  vault.command("set").argument("<name>", "Secret name (e.g., OPENAI_API_KEY)").argument("[value]", "Secret value (omit for secure prompt)").option("--category <cat>", "Category (api_key, token, secret, credential)", "api_key").option("--provider <provider>", "Provider name (openai, anthropic, etc.)").description("Store a secret securely").action(async (name, value, opts) => {
+    if (!value) {
+      value = await promptSecret(`Enter value for ${name}: `);
+    }
+    if (!value) {
+      error("Value is required.");
+      process.exit(1);
+    }
+    const client = createClient();
+    await safeCall(
+      () => client.mutation("vault:store", {
+        name,
+        encryptedValue: value,
+        category: opts.category,
+        provider: opts.provider
+      }),
+      "Failed to store secret"
+    );
+    success(`Secret "${name}" stored securely.`);
+  });
+  vault.command("get").argument("<name>", "Secret name").option("--reveal", "Show the actual value (use with caution)").description("Retrieve a secret").action(async (name, opts) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("vault:list", {}), "Failed");
+    const secret = (result || []).find((s) => s.name === name);
+    if (!secret) {
+      error(`Secret "${name}" not found.`);
+      process.exit(1);
+    }
+    if (opts.reveal) {
+      const value = await safeCall(
+        () => client.query("vault:getDecrypted", { _id: secret._id }),
+        "Failed to retrieve secret"
+      );
+      console.log(value);
+    } else {
+      const masked = secret.encryptedValue ? secret.encryptedValue.slice(0, 4) + "****" + secret.encryptedValue.slice(-4) : "****";
+      info(`${name} = ${masked}`);
+      dim("  Use --reveal to show the full value.");
+    }
+  });
+  vault.command("delete").argument("<name>", "Secret name").option("-f, --force", "Skip confirmation").description("Delete a secret").action(async (name, opts) => {
+    if (!opts.force) {
+      const confirm = await prompt7(`Delete secret "${name}"? This cannot be undone. (y/N): `);
+      if (confirm.toLowerCase() !== "y") {
+        info("Cancelled.");
+        return;
+      }
+    }
+    const client = createClient();
+    const result = await safeCall(() => client.query("vault:list", {}), "Failed");
+    const secret = (result || []).find((s) => s.name === name);
+    if (!secret) {
+      error(`Secret "${name}" not found.`);
+      process.exit(1);
+    }
+    await safeCall(() => client.mutation("vault:remove", { _id: secret._id }), "Failed");
+    success(`Secret "${name}" deleted.`);
+  });
+  vault.command("rotate").argument("<name>", "Secret name").description("Rotate a secret (set a new value)").action(async (name) => {
+    const client = createClient();
+    const result = await safeCall(() => client.query("vault:list", {}), "Failed");
+    const secret = (result || []).find((s) => s.name === name);
+    if (!secret) {
+      error(`Secret "${name}" not found.`);
+      process.exit(1);
+    }
+    const newValue = await promptSecret(`Enter new value for ${name}: `);
+    if (!newValue) {
+      error("Value is required.");
+      process.exit(1);
+    }
+    await safeCall(
+      () => client.mutation("vault:rotate", { _id: secret._id, newValue }),
+      "Failed to rotate secret"
+    );
+    success(`Secret "${name}" rotated.`);
+  });
+}
+
+// src/commands/status.ts
+import { spawn as spawn2 } from "child_process";
+import path8 from "path";
+import fs8 from "fs-extra";
+import readline9 from "readline";
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show system health and connection status").action(async () => {
+    header("AgentForge Status");
+    const cwd = process.cwd();
+    const checks = {};
+    checks["Project Root"] = fs8.existsSync(path8.join(cwd, "package.json")) ? "\u2714 Found" : "\u2716 Not found";
+    checks["Convex Dir"] = fs8.existsSync(path8.join(cwd, "convex")) ? "\u2714 Found" : "\u2716 Not found";
+    checks["Skills Dir"] = fs8.existsSync(path8.join(cwd, "skills")) ? "\u2714 Found" : "\u2716 Not configured";
+    checks["Dashboard Dir"] = fs8.existsSync(path8.join(cwd, "dashboard")) ? "\u2714 Found" : "\u2716 Not found";
+    checks["Env Config"] = fs8.existsSync(path8.join(cwd, ".env.local")) || fs8.existsSync(path8.join(cwd, ".env")) ? "\u2714 Found" : "\u2716 Not found";
+    try {
+      const client = createClient();
+      const agents = await client.query("agents:list", {});
+      checks["Convex Connection"] = `\u2714 Connected (${agents?.length || 0} agents)`;
+    } catch {
+      checks["Convex Connection"] = "\u2716 Not connected (run `npx convex dev`)";
+    }
+    const envFiles = [".env.local", ".env"];
+    let provider = "Not configured";
+    for (const envFile of envFiles) {
+      const envPath = path8.join(cwd, envFile);
+      if (fs8.existsSync(envPath)) {
+        const content = fs8.readFileSync(envPath, "utf-8");
+        const match = content.match(/LLM_PROVIDER=(.+)/);
+        if (match) {
+          provider = match[1].trim();
+          break;
+        }
+        if (content.includes("OPENAI_API_KEY=")) {
+          provider = "openai";
+          break;
+        }
+        if (content.includes("OPENROUTER_API_KEY=")) {
+          provider = "openrouter";
+          break;
+        }
+      }
+    }
+    checks["LLM Provider"] = provider !== "Not configured" ? `\u2714 ${provider}` : "\u2716 Not configured";
+    details(checks);
+  });
+  program2.command("dashboard").description("Launch the web dashboard").option("-p, --port <port>", "Port for the dashboard", "3000").option("--install", "Install dashboard dependencies before starting").action(async (opts) => {
+    const cwd = process.cwd();
+    const searchPaths = [
+      path8.join(cwd, "dashboard"),
+      // 1. Bundled in project (agentforge create)
+      path8.join(cwd, "packages", "web"),
+      // 2. Monorepo structure
+      path8.join(cwd, "node_modules", "@agentforge-ai", "web")
+      // 3. Installed as dependency
+    ];
+    let dashDir = "";
+    for (const p of searchPaths) {
+      if (fs8.existsSync(path8.join(p, "package.json"))) {
+        dashDir = p;
+        break;
+      }
+    }
+    if (!dashDir) {
+      error("Dashboard not found!");
+      console.log();
+      info("The dashboard should be in your project's ./dashboard/ directory.");
+      info("If you created this project with an older version of AgentForge,");
+      info("you can add it manually:");
+      console.log();
+      console.log(`  ${colors.cyan}# Option 1: Recreate the project${colors.reset}`);
+      console.log(`  agentforge create my-project`);
+      console.log();
+      console.log(`  ${colors.cyan}# Option 2: Clone the dashboard from the repo${colors.reset}`);
+      console.log(`  git clone https://github.com/Agentic-Engineering-Agency/agentforge /tmp/af`);
+      console.log(`  cp -r /tmp/af/packages/web ./dashboard`);
+      console.log(`  cd dashboard && pnpm install`);
+      console.log();
+      return;
+    }
+    const nodeModulesExists = fs8.existsSync(path8.join(dashDir, "node_modules"));
+    if (!nodeModulesExists || opts.install) {
+      header("AgentForge Dashboard \u2014 Installing Dependencies");
+      info(`Installing in ${path8.relative(cwd, dashDir) || "."}...`);
+      console.log();
+      const installChild = spawn2("pnpm", ["install"], {
+        cwd: dashDir,
+        stdio: "inherit",
+        shell: true
+      });
+      await new Promise((resolve2, reject) => {
+        installChild.on("close", (code) => {
+          if (code === 0) resolve2();
+          else reject(new Error(`pnpm install exited with code ${code}`));
+        });
+        installChild.on("error", reject);
+      });
+      console.log();
+      success("Dependencies installed.");
+      console.log();
+    }
+    const envPath = path8.join(cwd, ".env.local");
+    if (fs8.existsSync(envPath)) {
+      const envContent = fs8.readFileSync(envPath, "utf-8");
+      const convexUrlMatch = envContent.match(/CONVEX_URL=(.+)/);
+      if (convexUrlMatch) {
+        const dashEnvPath = path8.join(dashDir, ".env.local");
+        const dashEnvContent = `VITE_CONVEX_URL=${convexUrlMatch[1].trim()}
+`;
+        fs8.writeFileSync(dashEnvPath, dashEnvContent);
+      }
+    }
+    header("AgentForge Dashboard");
+    info(`Starting dashboard on port ${opts.port}...`);
+    info(`Open ${colors.cyan}http://localhost:${opts.port}${colors.reset} in your browser.`);
+    console.log();
+    const child = spawn2("pnpm", ["dev", "--port", opts.port], {
+      cwd: dashDir,
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("error", (err) => {
+      error(`Failed to start dashboard: ${err.message}`);
+    });
+  });
+  program2.command("logs").description("Show recent activity logs").option("-n, --lines <count>", "Number of log entries", "20").option("--agent <id>", "Filter by agent ID").option("--json", "Output as JSON").action(async (opts) => {
+    const client = createClient();
+    const args = {};
+    if (opts.agent) args.agentId = opts.agent;
+    const result = await safeCall(
+      () => client.query("usage:list", args),
+      "Failed to fetch logs"
+    );
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Activity Logs");
+    const items = (result || []).slice(0, parseInt(opts.lines));
+    if (items.length === 0) {
+      info("No activity logs found.");
+      return;
+    }
+    items.forEach((log) => {
+      const time = new Date(log.timestamp || log.createdAt).toLocaleString();
+      const agent = log.agentId || "system";
+      const action = log.action || log.type || "unknown";
+      const tokens = log.tokensUsed ? `${log.tokensUsed} tokens` : "";
+      console.log(`  ${colors.dim}${time}${colors.reset}  ${colors.cyan}${agent}${colors.reset}  ${action}  ${tokens}`);
+    });
+    console.log();
+  });
+  program2.command("heartbeat").description("Check and resume pending agent tasks").option("--agent <id>", "Check specific agent").action(async (opts) => {
+    const client = createClient();
+    header("Heartbeat Check");
+    const args = {};
+    if (opts.agent) args.agentId = opts.agent;
+    const result = await safeCall(
+      () => client.query("heartbeat:listPending", args),
+      "Failed to check heartbeat"
+    );
+    const items = result || [];
+    if (items.length === 0) {
+      success("All tasks complete. No pending work.");
+      return;
+    }
+    info(`Found ${items.length} pending task(s):`);
+    items.forEach((task, i) => {
+      console.log(`  ${colors.yellow}${i + 1}.${colors.reset} [${task.agentId}] ${task.taskDescription || "Unnamed task"}`);
+      console.log(`     ${colors.dim}Status: ${task.status} | Thread: ${task.threadId || "N/A"}${colors.reset}`);
+    });
+    console.log();
+    const rl = readline9.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((r) => rl.question("Resume pending tasks? (y/N): ", (a) => {
+      rl.close();
+      r(a.trim());
+    }));
+    if (answer.toLowerCase() === "y") {
+      for (const task of items) {
+        info(`Resuming task for agent "${task.agentId}"...`);
+        await safeCall(
+          () => client.mutation("heartbeat:resume", { _id: task._id }),
+          "Failed to resume task"
+        );
+      }
+      success("All pending tasks resumed.");
+    }
+  });
+}
+
 // src/index.ts
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -240,7 +1792,7 @@ var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname(__filename2);
 var pkg = JSON.parse(readFileSync(resolve(__dirname2, "..", "package.json"), "utf-8"));
 var program = new Command();
-program.name("agentforge").description("CLI tool for creating, running, and managing AgentForge projects").version(pkg.version);
+program.name("agentforge").description("AgentForge \u2014 NanoClaw: A minimalist agent framework powered by Mastra + Convex").version(pkg.version);
 program.command("create").argument("<project-name>", "Name of the project to create").description("Create a new AgentForge project").option("-t, --template <template>", "Project template to use", "default").action(async (projectName, options) => {
   await createProject(projectName, options);
 });
@@ -250,5 +1802,17 @@ program.command("run").description("Start the local development environment").op
 program.command("deploy").description("Deploy the Convex backend to production").option("--env <path>", "Path to environment file", ".env.production").option("--dry-run", "Preview deployment without executing", false).option("--rollback", "Rollback to previous deployment", false).option("--force", "Skip confirmation prompts", false).action(async (options) => {
   await deployProject(options);
 });
+registerAgentsCommand(program);
+registerChatCommand(program);
+registerSessionsCommand(program);
+registerThreadsCommand(program);
+registerSkillsCommand(program);
+registerCronCommand(program);
+registerMcpCommand(program);
+registerFilesCommand(program);
+registerProjectsCommand(program);
+registerConfigCommand(program);
+registerVaultCommand(program);
+registerStatusCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map