@archon-claw/cli 0.0.4 → 0.2.0

package/dist/cli.js

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "url";
 import path from "path";
-import { readFileSync } from "fs";
+import { readFileSync, readdirSync, statSync } from "fs";
 import dotenv from "dotenv";
 import { Command } from "commander";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 import { loadAgentConfig } from "./config.js";
 import { createServer } from "./server.js";
-import { initSessionStore } from "./session.js";
+import { SessionStore } from "./session.js";
+import { startDev } from "./dev.js";
 import { runToolTests, formatResults } from "./test-runner.js";
 import { runEvals } from "./eval/runner.js";
-import { scaffoldAgent, scaffoldWorkspace } from "./scaffold.js";
+import { scaffoldAgent, scaffoldWorkspace, updateSkills } from "./scaffold.js";
 const pkg = JSON.parse(readFileSync(path.resolve(__dirname, "../package.json"), "utf-8"));
 const program = new Command();
 program
@@ -30,31 +31,76 @@ program
     .action(() => {
     console.log("Starting agent...");
 });
+/** Scan a directory for agent subdirectories and load them all */
+async function loadAgentsFromDir(agentsDir) {
+    const absDir = path.resolve(agentsDir);
+    const entries = readdirSync(absDir);
+    const agents = new Map();
+    for (const name of entries) {
+        const fullPath = path.join(absDir, name);
+        if (!statSync(fullPath).isDirectory())
+            continue;
+        // Skip hidden dirs and common non-agent dirs
+        if (name.startsWith(".") || name === "node_modules")
+            continue;
+        try {
+            const config = await loadAgentConfig(fullPath);
+            const sessions = new SessionStore(fullPath);
+            await sessions.init();
+            agents.set(name, { config, sessions });
+        }
+        catch (err) {
+            console.warn(`[warn] Skipping "${name}": ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    if (agents.size === 0) {
+        throw new Error(`No valid agents found in ${absDir}`);
+    }
+    return agents;
+}
+program
+    .command("dev")
+    .description("Start dev server with hot-reload for agent development")
+    .requiredOption("--agents-dir <path>", "Path to directory containing agent subdirectories")
+    .option("-p, --port <port>", "Server port", "5100")
+    .option("--no-open", "Don't auto-open browser")
+    .action(async (opts) => {
+    try {
+        await startDev(opts.agentsDir, {
+            port: parseInt(opts.port, 10),
+            open: opts.open,
+        });
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
 program
     .command("start")
     .description("Start an agent HTTP server")
-    .argument("<agent-dir>", "Path to agent directory")
+    .requiredOption("--agents-dir <path>", "Path to directory containing agent subdirectories")
     .option("-p, --port <port>", "Server port", "5100")
-    .action(async (agentDir, opts) => {
+    .action(async (opts) => {
     try {
-        const config = await loadAgentConfig(agentDir);
-        await initSessionStore(agentDir);
+        const agents = await loadAgentsFromDir(opts.agentsDir);
         const port = parseInt(opts.port, 10);
-        console.log(`Agent loaded:`);
-        console.log(`  Model: ${config.model.provider}/${config.model.model}`);
-        console.log(`  Tools: ${config.tools.map((t) => t.name).join(", ")}`);
-        if (config.mcpManager) {
-            const servers = config.mcpManager.getServerNames();
-            console.log(`  MCP servers: ${servers.join(", ")}`);
+        console.log("Agents loaded:");
+        for (const [id, entry] of agents) {
+            const { config } = entry;
+            const mcpCount = config.mcpManager ? config.mcpManager.getServerNames().length : 0;
+            console.log(`  [${id}]  Model: ${config.model.provider}/${config.model.model}` +
+                `  Tools: ${config.tools.length}` +
+                (mcpCount > 0 ? `  MCP: ${mcpCount} servers` : "") +
+                `  Skills: ${Object.keys(config.skills).length}`);
         }
-        console.log(`  Skills: ${Object.keys(config.skills).join(", ") || "(none)"}`);
-        console.log(`  System prompt: ${config.systemPrompt.length} chars`);
-        const server = createServer(config, port);
+        const server = createServer(agents, port);
         const shutdown = async () => {
             console.log("\nShutting down...");
-            await config.mcpManager?.shutdown();
+            for (const [, entry] of agents) {
+                await entry.config.mcpManager?.shutdown();
+            }
             server.close(() => process.exit(0));
-            // Force exit if server hasn't closed within 3s
             setTimeout(() => process.exit(1), 3000).unref();
         };
         process.on("SIGINT", shutdown);
@@ -113,11 +159,40 @@ program
 });
 program
     .command("init")
-    .description("Initialise an agent workspace with shared .claude/ skills")
-    .argument("[dir]", "Directory to initialise", "./agents")
-    .action(async (dir) => {
+    .description("Initialise an agent workspace project")
+    .argument("[dir]", "Directory to initialise")
+    .option("--install", "Automatically install npm dependencies")
+    .action(async (dir, opts) => {
     try {
-        await scaffoldWorkspace(dir);
+        const { intro, text, confirm, isCancel, outro } = await import("@clack/prompts");
+        intro("archon-claw init");
+        if (!dir) {
+            const name = await text({
+                message: "Project name",
+                placeholder: "my-ai-agent",
+                validate: (v) => {
+                    if (!v?.trim())
+                        return "Project name is required";
+                    if (!/^[a-z0-9._-]+$/i.test(v))
+                        return "Invalid directory name";
+                },
+            });
+            if (isCancel(name)) {
+                outro("Cancelled");
+                return;
+            }
+            dir = name;
+        }
+        if (opts.install === undefined) {
+            const install = await confirm({ message: "Install dependencies?" });
+            if (isCancel(install)) {
+                outro("Cancelled");
+                return;
+            }
+            opts.install = install;
+        }
+        await scaffoldWorkspace(dir, { install: opts.install });
+        outro("Done!");
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : err);
@@ -125,13 +200,49 @@ program
     }
 });
 program
-    .command("create")
+    .command("create-agent")
     .description("Create a new agent project")
-    .argument("<agent-name>", "Name of the agent (used as directory name)")
+    .argument("[agent-name]", "Name of the agent (used as directory name)")
     .option("-d, --dir <path>", "Parent directory for the agent", "./agents")
     .action(async (agentName, opts) => {
     try {
-        await scaffoldAgent(agentName, opts.dir);
+        if (!agentName) {
+            const { intro, text, isCancel, outro } = await import("@clack/prompts");
+            intro("archon-claw create");
+            const name = await text({
+                message: "Agent name",
+                placeholder: "my-agent",
+                validate: (v) => {
+                    if (!v?.trim())
+                        return "Agent name is required";
+                    if (!/^[a-z0-9._-]+$/i.test(v))
+                        return "Invalid directory name";
+                },
+            });
+            if (isCancel(name)) {
+                outro("Cancelled");
+                return;
+            }
+            agentName = name;
+            await scaffoldAgent(agentName, opts.dir);
+            outro("Done!");
+        }
+        else {
+            await scaffoldAgent(agentName, opts.dir);
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("update-skills")
+    .description("Update skills to the latest version bundled with @archon-claw/cli")
+    .argument("[dir]", "Workspace directory", ".")
+    .action(async (dir) => {
+    try {
+        await updateSkills(dir);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : err);

package/dist/config.js

@@ -11,7 +11,7 @@ export async function loadAgentConfig(agentDir) {
     // Validate directory structure
     const validation = await validateDir("agent-dir", absDir);
     if (!validation.valid) {
-        throw new Error(`Invalid agent directory:\n${validation.errors.map((e) => `  - ${e}`).join("\n")}`);
+        throw new Error(`Invalid agent directory:\n${validation.errors.map((e) => `  - ${e.file ? `[${e.file}] ` : ""}${e.message}`).join("\n")}`);
     }
     // Load model.json
     const modelRaw = await fs.readFile(path.join(absDir, "model.json"), "utf-8");
@@ -74,7 +74,8 @@ export async function loadAgentConfig(agentDir) {
         const implEntries = await Promise.all(implFiles.map(async (file) => {
             const name = file.replace(/\.impl\.js$/, "");
             const implPath = pathToFileURL(path.join(implsDir, file)).href;
-            const mod = await import(implPath);
+            // Cache-bust ESM module cache so dev reload picks up changes
+            const mod = await import(`${implPath}?t=${Date.now()}`);
             return [name, mod.default];
         }));
         for (const [name, impl] of implEntries) {

package/dist/dev.d.ts

@@ -0,0 +1,20 @@
+import http from "node:http";
+import { type FSWatcher } from "chokidar";
+import { type AgentEntry } from "./server.js";
+export interface DevOptions {
+    port: number;
+    open: boolean;
+}
+/** Returned by startDev for cleanup and testing */
+export interface DevHandle {
+    server: http.Server;
+    watchers: FSWatcher[];
+    /** Current agents map (mutable via reload) */
+    getAgents(): Map<string, AgentEntry>;
+    /** Manually trigger config reload for a specific agent */
+    reloadAgent(agentId: string, changedFiles?: string[]): Promise<void>;
+    /** Graceful shutdown */
+    close(): Promise<void>;
+}
+export declare function startDev(agentsDir: string, opts: DevOptions): Promise<DevHandle>;
+export declare function printBanner(agents: Map<string, AgentEntry>, port: number, absDir: string): void;

package/dist/dev.js

@@ -0,0 +1,170 @@
+import path from "node:path";
+import { readdirSync, statSync } from "node:fs";
+import { watch } from "chokidar";
+import open from "open";
+import { loadAgentConfig } from "./config.js";
+import { createServer } from "./server.js";
+import { SessionStore } from "./session.js";
+/** Scan agents-dir for valid agent subdirectories */
+function scanAgentDirs(agentsDir) {
+    const results = [];
+    for (const name of readdirSync(agentsDir)) {
+        const fullPath = path.join(agentsDir, name);
+        if (!statSync(fullPath).isDirectory())
+            continue;
+        if (name.startsWith(".") || name === "node_modules")
+            continue;
+        results.push({ id: name, path: fullPath });
+    }
+    return results;
+}
+export async function startDev(agentsDir, opts) {
+    const absDir = path.resolve(agentsDir);
+    const agentDirs = scanAgentDirs(absDir);
+    if (agentDirs.length === 0) {
+        throw new Error(`No agent directories found in ${absDir}`);
+    }
+    // Initial load of all agents
+    const currentAgents = new Map();
+    for (const { id, path: agentPath } of agentDirs) {
+        try {
+            const config = await loadAgentConfig(agentPath);
+            const sessions = new SessionStore(agentPath);
+            await sessions.init();
+            currentAgents.set(id, { config, sessions });
+        }
+        catch (err) {
+            console.warn(`[dev] Skipping "${id}": ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    if (currentAgents.size === 0) {
+        throw new Error(`No valid agents found in ${absDir}`);
+    }
+    // Start server with getter — every request reads latest agents
+    const server = createServer(() => currentAgents, opts.port);
+    printBanner(currentAgents, opts.port, absDir);
+    // Open browser (skip in SSH)
+    if (opts.open && !process.env.SSH_CLIENT && !process.env.SSH_TTY) {
+        open(`http://localhost:${opts.port}`).catch(() => { });
+    }
+    // Per-agent reload logic
+    const reloadInFlight = new Set();
+    async function reloadAgent(agentId, changedFiles) {
+        if (reloadInFlight.has(agentId))
+            return;
+        reloadInFlight.add(agentId);
+        const agentEntry = agentDirs.find((d) => d.id === agentId);
+        if (!agentEntry) {
+            reloadInFlight.delete(agentId);
+            return;
+        }
+        const ts = new Date().toLocaleTimeString();
+        if (changedFiles?.length) {
+            const relFiles = changedFiles.map((f) => path.relative(agentEntry.path, f));
+            console.log(`\n[dev] ${ts} [${agentId}] Changed: ${relFiles.join(", ")}`);
+        }
+        try {
+            const existing = currentAgents.get(agentId);
+            await existing?.config.mcpManager?.shutdown();
+            const newConfig = await loadAgentConfig(agentEntry.path);
+            const sessions = existing?.sessions ?? new SessionStore(agentEntry.path);
+            if (!existing)
+                await sessions.init();
+            currentAgents.set(agentId, { config: newConfig, sessions });
+            console.log(`[dev] ${ts} [${agentId}] Reloaded \u2713` +
+                ` (tools: ${newConfig.tools.length}, skills: ${Object.keys(newConfig.skills).length})`);
+        }
+        catch (err) {
+            console.error(`[dev] ${ts} [${agentId}] Reload failed: ${err instanceof Error ? err.message : err}`);
+            console.error(`[dev] Continuing with previous valid configuration`);
+        }
+        finally {
+            reloadInFlight.delete(agentId);
+        }
+    }
+    // Watch each agent directory
+    const watchers = [];
+    for (const { id, path: agentPath } of agentDirs) {
+        if (!currentAgents.has(id))
+            continue; // Skip agents that failed to load
+        const watcher = watch(agentPath, {
+            ignored: [
+                "**/sessions/**",
+                "**/node_modules/**",
+                "**/eval-results/**",
+                "**/.DS_Store",
+            ],
+            ignoreInitial: true,
+        });
+        let debounceTimer = null;
+        let pendingFiles = [];
+        watcher.on("all", (_event, filePath) => {
+            pendingFiles.push(filePath);
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(async () => {
+                const files = [...pendingFiles];
+                pendingFiles = [];
+                await reloadAgent(id, files);
+            }, 100);
+        });
+        watchers.push(watcher);
+    }
+    // Graceful shutdown
+    const shutdown = async () => {
+        console.log("\nShutting down...");
+        await close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    async function close() {
+        process.removeListener("SIGINT", shutdown);
+        process.removeListener("SIGTERM", shutdown);
+        for (const watcher of watchers) {
+            await watcher.close();
+        }
+        for (const [, entry] of currentAgents) {
+            await entry.config.mcpManager?.shutdown();
+        }
+        await new Promise((resolve) => server.close(() => resolve()));
+    }
+    return {
+        server,
+        watchers,
+        getAgents: () => currentAgents,
+        reloadAgent,
+        close,
+    };
+}
+export function printBanner(agents, port, absDir) {
+    const lines = [
+        "",
+        "  archon-claw dev",
+        "",
+        `  Agents dir: ${path.relative(process.cwd(), absDir)}`,
+        "",
+    ];
+    for (const [id, entry] of agents) {
+        const { config } = entry;
+        const mcpCount = config.mcpManager
+            ? config.mcpManager.getServerNames().length
+            : 0;
+        lines.push(`  [${id}]  ${config.model.provider}/${config.model.model}` +
+            `  tools: ${config.tools.length}${mcpCount > 0 ? ` (+${mcpCount} mcp)` : ""}` +
+            `  skills: ${Object.keys(config.skills).length}`);
+    }
+    lines.push("");
+    lines.push(`  URL: http://localhost:${port}`);
+    lines.push("");
+    lines.push("  Watching for changes...");
+    lines.push("");
+    const maxLen = Math.max(...lines.map((l) => l.length));
+    const top = "\u250C" + "\u2500".repeat(maxLen + 1) + "\u2510";
+    const bot = "\u2514" + "\u2500".repeat(maxLen + 1) + "\u2518";
+    console.log(top);
+    for (const line of lines) {
+        console.log("\u2502" + line.padEnd(maxLen + 1) + "\u2502");
+    }
+    console.log(bot);
+}

package/dist/mcp-server.d.ts

@@ -0,0 +1,5 @@
+import type http from "node:http";
+import type { AgentEntry } from "./server.js";
+type AgentMap = Map<string, AgentEntry>;
+export declare function handleMcpRequest(agents: AgentMap, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export {};

package/dist/mcp-server.js

@@ -0,0 +1,106 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
+import { runAgentLoop } from "./agent.js";
+function setupTools(server, agents) {
+    server.registerTool("list_agents", {
+        description: "List available agents",
+    }, async () => {
+        const list = [...agents.entries()].map(([id, entry]) => ({
+            id,
+            toolCount: entry.config.tools.length,
+            skillCount: Object.keys(entry.config.skills).length,
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+    });
+    server.registerTool("chat", {
+        description: "Send a message to an agent and get a response. Only server-side tools are available; client/host tools are excluded.",
+        inputSchema: z.object({
+            agent: z.string().describe("Agent ID"),
+            message: z.string().describe("User message"),
+            sessionId: z.string().optional().describe("Session ID for conversation continuity"),
+            context: z.record(z.unknown()).optional().describe("Additional context passed to the agent system prompt"),
+        }),
+    }, async ({ agent, message, sessionId, context }) => {
+        const entry = agents.get(agent);
+        if (!entry) {
+            return { content: [{ type: "text", text: `Agent not found: ${agent}` }], isError: true };
+        }
+        const { config, sessions } = entry;
+        // Filter to server-side tools only (client/host tools can't execute without a browser)
+        const serverTools = config.tools.filter(t => (t.execution_target ?? "server") === "server");
+        const filteredConfig = { ...config, tools: serverTools };
+        const session = await sessions.getOrCreate(sessionId);
+        const texts = [];
+        try {
+            await runAgentLoop(filteredConfig, session, message, (event) => {
+                if (event.type === "text")
+                    texts.push(event.content);
+            }, context);
+        }
+        catch (err) {
+            await sessions.save(session);
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+        await sessions.save(session);
+        return {
+            content: [{ type: "text", text: texts.join("") }],
+            structuredContent: { response: texts.join(""), sessionId: session.id },
+        };
+    });
+    server.registerTool("list_sessions", {
+        description: "List chat sessions for an agent",
+        inputSchema: z.object({
+            agent: z.string().describe("Agent ID"),
+        }),
+    }, async ({ agent }) => {
+        const entry = agents.get(agent);
+        if (!entry) {
+            return { content: [{ type: "text", text: `Agent not found: ${agent}` }], isError: true };
+        }
+        const all = await entry.sessions.list();
+        const list = all.map((s) => {
+            const firstUser = s.messages.find((m) => m.role === "user");
+            const title = firstUser
+                ? firstUser.content.slice(0, 50) + (firstUser.content.length > 50 ? "..." : "")
+                : undefined;
+            return { id: s.id, title, messageCount: s.messages.length, createdAt: s.createdAt, updatedAt: s.updatedAt };
+        }).sort((a, b) => b.updatedAt - a.updatedAt);
+        return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+    });
+    server.registerTool("get_session", {
+        description: "Get session details and message history",
+        inputSchema: z.object({
+            agent: z.string().describe("Agent ID"),
+            sessionId: z.string().describe("Session ID"),
+        }),
+    }, async ({ agent, sessionId }) => {
+        const entry = agents.get(agent);
+        if (!entry) {
+            return { content: [{ type: "text", text: `Agent not found: ${agent}` }], isError: true };
+        }
+        const session = await entry.sessions.get(sessionId);
+        if (!session) {
+            return { content: [{ type: "text", text: "Session not found" }], isError: true };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(session, null, 2) }] };
+    });
+}
+export async function handleMcpRequest(agents, req, res) {
+    const server = new McpServer({ name: "archon-claw", version: "1.0.0" });
+    setupTools(server, agents);
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+        enableJsonResponse: true,
+    });
+    try {
+        await server.connect(transport);
+        await transport.handleRequest(req, res);
+    }
+    finally {
+        await server.close();
+    }
+}