@townco/cli 0.1.22 → 0.1.24

package/dist/commands/configure.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { isInsideTownProject } from "@townco/agent/storage";
 import inquirer from "inquirer";
 const ENV_KEYS = [
     {
@@ -20,14 +20,20 @@ const ENV_KEYS = [
         required: false,
     },
 ];
-function getConfigDir() {
-    return join(homedir(), ".config", "town");
+async function getProjectRoot() {
+    const projectRoot = await isInsideTownProject();
+    if (projectRoot === null) {
+        console.error("❌ Error: Not inside a Town project.");
+        console.error("\nRun `town create --init <path>` to initialize a project first.");
+        process.exit(1);
+    }
+    return projectRoot;
 }
-function getEnvFilePath() {
-    return join(getConfigDir(), ".env");
+function getEnvFilePath(projectRoot) {
+    return join(projectRoot, ".env");
 }
-async function loadExistingEnv() {
-    const envPath = getEnvFilePath();
+async function loadExistingEnv(projectRoot) {
+    const envPath = getEnvFilePath(projectRoot);
     if (!existsSync(envPath)) {
         return {};
     }
@@ -45,9 +51,9 @@ async function loadExistingEnv() {
     }
     return config;
 }
-async function saveEnv(config) {
-    const configDir = getConfigDir();
-    await mkdir(configDir, { recursive: true });
+async function saveEnv(config, projectRoot) {
+    // Ensure project root exists (it should, but just to be safe)
+    await mkdir(projectRoot, { recursive: true });
     const lines = [
         "# Town CLI Configuration",
         "# Environment variables for Town agents",
@@ -61,11 +67,13 @@ async function saveEnv(config) {
             lines.push("");
         }
     }
-    await writeFile(getEnvFilePath(), lines.join("\n"), "utf-8");
+    await writeFile(getEnvFilePath(projectRoot), lines.join("\n"), "utf-8");
 }
 export async function configureCommand() {
     console.log("🔧 Town Configuration\n");
-    const existingConfig = await loadExistingEnv();
+    // Get project root (will error and exit if not in a project)
+    const projectRoot = await getProjectRoot();
+    const existingConfig = await loadExistingEnv(projectRoot);
     const hasExisting = Object.keys(existingConfig).length > 0;
     if (hasExisting) {
         console.log("Found existing configuration:\n");
@@ -140,7 +148,7 @@ export async function configureCommand() {
         }
     }
     // Save configuration
-    await saveEnv(newConfig);
-    console.log(`\n✅ Configuration saved to ${getEnvFilePath()}`);
+    await saveEnv(newConfig, projectRoot);
+    console.log(`\n✅ Configuration saved to ${getEnvFilePath(projectRoot)}`);
     console.log("\nThese environment variables will be automatically loaded when running agents.");
 }

package/dist/commands/create-project.d.ts

@@ -0,0 +1,7 @@
+export interface CreateProjectCommandProps {
+    path?: string;
+}
+/**
+ * Create a new standalone project with agents and tools
+ */
+export declare function createProjectCommand(props?: CreateProjectCommandProps): Promise<void>;

package/dist/commands/create-project.js

@@ -0,0 +1,22 @@
+import { resolve } from "node:path";
+import { scaffoldProject } from "@townco/agent/scaffold";
+/**
+ * Create a new standalone project with agents and tools
+ */
+export async function createProjectCommand(props = {}) {
+    const { path = process.cwd() } = props;
+    // Resolve the path to absolute
+    const projectPath = resolve(path);
+    console.log(`Creating new Town agents project at: ${projectPath}`);
+    const result = await scaffoldProject({
+        path: projectPath,
+    });
+    if (result.success) {
+        console.log("\n✓ Project created successfully!");
+        console.log(`\nProject path: ${result.path}`);
+    }
+    else {
+        console.error(`\n✗ Error creating project: ${result.error}`);
+        process.exit(1);
+    }
+}

package/dist/commands/create.d.ts

@@ -1,8 +1,10 @@
 interface CreateCommandProps {
-	name?: string;
-	model?: string;
-	tools?: readonly string[];
-	systemPrompt?: string;
-	overwrite?: boolean;
+    name?: string;
+    model?: string;
+    tools?: readonly string[];
+    systemPrompt?: string;
+    overwrite?: boolean;
+    agentsDir: string;
 }
 export declare function createCommand(props: CreateCommandProps): Promise<void>;
+export {};

package/dist/commands/create.js

@@ -52,7 +52,7 @@ function NameInput({ nameInput, setNameInput, onSubmit }) {
     });
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Enter agent name:" }) }), _jsxs(Box, { children: [_jsxs(Text, { children: [">", " "] }), _jsx(TextInput, { value: nameInput, onChange: setNameInput, onSubmit: onSubmit })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Continue \u2022 Esc: Cancel" }) })] }));
 }
-function CreateApp({ name: initialName, model: initialModel, tools: initialTools, systemPrompt: initialSystemPrompt, overwrite = false, }) {
+function CreateApp({ name: initialName, model: initialModel, tools: initialTools, systemPrompt: initialSystemPrompt, overwrite = false, agentsDir, }) {
     // Determine the starting stage based on what's provided
     const determineInitialStage = () => {
         if (!initialName)
@@ -119,14 +119,17 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
             }
             const name = agentDef.name;
             const model = agentDef.model;
+            const definition = {
+                model,
+                systemPrompt: agentDef.systemPrompt || null,
+                tools: agentDef.tools || [],
+            };
+            // Create agent in project
             scaffoldAgent({
                 name,
-                definition: {
-                    model,
-                    systemPrompt: agentDef.systemPrompt || null,
-                    tools: agentDef.tools || [],
-                },
+                definition,
                 overwrite,
+                agentsDir,
             }).then((result) => {
                 if (result.success) {
                     setScaffoldStatus("done");
@@ -142,7 +145,7 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
                 }
             });
         }
-    }, [stage, scaffoldStatus, agentDef, overwrite]);
+    }, [stage, scaffoldStatus, agentDef, overwrite, agentsDir]);
     // Name stage
     if (stage === "name") {
         return (_jsx(NameInput, { nameInput: nameInput, setNameInput: setNameInput, onSubmit: () => {
@@ -294,7 +297,7 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
         }
         if (scaffoldStatus === "done") {
             const modelLabel = agentDef.model?.replace("claude-", "") || "";
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Agent created successfully!" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: "green", children: "\u25CF" }), " ", _jsx(Text, { bold: true, children: agentDef.name })] }), _jsxs(Text, { dimColor: true, children: [" Model: ", modelLabel] }), agentDef.tools && agentDef.tools.length > 0 && (_jsxs(Text, { dimColor: true, children: [" Tools: ", agentDef.tools.join(", ")] })), _jsxs(Text, { dimColor: true, children: [" Path: ", agentPath] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Run an agent with: town run ", agentDef.name] }), _jsx(Text, { dimColor: true, children: "TUI mode (default), --gui for web interface, --http for API server" })] })] }));
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Agent created successfully!" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: "green", children: "\u25CF" }), " ", _jsx(Text, { bold: true, children: agentDef.name })] }), _jsxs(Text, { dimColor: true, children: [" Model: ", modelLabel] }), agentDef.tools && agentDef.tools.length > 0 && (_jsxs(Text, { dimColor: true, children: [" Tools: ", agentDef.tools.join(", ")] })), _jsxs(Text, { dimColor: true, children: [" Path: ", agentPath] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Run agent: bun agents/", agentDef.name, "/index.ts stdio"] }), _jsxs(Text, { dimColor: true, children: ["GUI: cd agents/", agentDef.name, "/gui && bun run dev"] }), _jsxs(Text, { dimColor: true, children: ["TUI: cd agents/", agentDef.name, "/tui && bun start"] })] })] }));
         }
     }
     return null;

package/dist/commands/edit.js

@@ -1,10 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { agentExists, getAgentPath } from "@townco/agent/storage";
+import { isInsideTownProject } from "@townco/agent/storage";
 import { createCommand } from "./create.js";
-async function loadAgentConfig(name) {
+async function loadAgentConfig(name, agentPath) {
     try {
-        const agentPath = getAgentPath(name);
         const indexPath = join(agentPath, "index.ts");
         const content = await readFile(indexPath, "utf-8");
         // Parse model
@@ -55,15 +54,25 @@ async function loadAgentConfig(name) {
     }
 }
 export async function editCommand(name) {
-    // Check if agent exists
-    const exists = await agentExists(name);
-    if (!exists) {
+    // Check if we're inside a Town project
+    const projectRoot = await isInsideTownProject();
+    if (projectRoot === null) {
+        console.error("Error: Not inside a Town project.\n\n" +
+            "Please run 'town edit' inside a project directory.");
+        process.exit(1);
+    }
+    const agentPath = join(projectRoot, "agents", name);
+    // Check if the agent exists
+    try {
+        await readFile(join(agentPath, "agent.json"), "utf-8");
+    }
+    catch {
         console.error(`Error: Agent "${name}" not found.`);
         console.log('\nCreate an agent with "town create" or list agents with "town list"');
         process.exit(1);
     }
     // Load existing config
-    const config = await loadAgentConfig(name);
+    const config = await loadAgentConfig(name, agentPath);
     if (!config) {
         console.error(`Error: Failed to load agent configuration for "${name}".`);
         process.exit(1);
@@ -78,5 +87,6 @@ export async function editCommand(name) {
             systemPrompt: config.systemPrompt,
         }),
         overwrite: true,
+        agentsDir: join(projectRoot, "agents"),
     });
 }

package/dist/commands/run.js

@@ -2,9 +2,8 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
-import { agentExists, getAgentPath } from "@townco/agent/storage";
+import { isInsideTownProject } from "@townco/agent/storage";
 import { createLogger } from "@townco/agent/utils";
 import { AcpClient } from "@townco/ui";
 import { ChatView } from "@townco/ui/tui";
@@ -100,10 +99,11 @@ function GuiRunner({ agentProcess, guiProcess, agentPort, agentPath, logger, onE
     ], [agentProcess, guiProcess, agentPort]);
     return (_jsx(TabbedOutput, { processes: processes, logsDir: join(agentPath, ".logs"), onExit: onExit, onPortDetected: handlePortDetected }));
 }
-async function loadEnvVars(logger) {
-    const envPath = join(homedir(), ".config", "town", ".env");
+async function loadEnvVars(projectRoot, logger) {
+    const envPath = join(projectRoot, ".env");
     const envVars = {};
     if (!existsSync(envPath)) {
+        logger?.debug("No .env file found in project root", { path: envPath });
         return envVars;
     }
     try {
@@ -133,16 +133,29 @@ async function loadEnvVars(logger) {
 }
 export async function runCommand(options) {
     const { name, http = false, gui = false, port = 3100 } = options;
-    // Load environment variables from ~/.config/town/.env
-    const configEnvVars = await loadEnvVars();
+    // Check if we're inside a Town project
+    const projectRoot = await isInsideTownProject();
+    if (projectRoot === null) {
+        console.error("Error: Not inside a Town project.");
+        console.log('\nPlease run "town run" inside a project directory, or run:\n' +
+            "  town create --init <path>\n" +
+            "to create a project.");
+        process.exit(1);
+    }
+    // Load environment variables from project .env
+    const configEnvVars = await loadEnvVars(projectRoot);
+    // Resolve agent path within the project
+    const agentPath = join(projectRoot, "agents", name);
     // Check if agent exists
-    const exists = await agentExists(name);
-    if (!exists) {
+    try {
+        const { stat } = await import("node:fs/promises");
+        await stat(agentPath);
+    }
+    catch {
         console.error(`Error: Agent "${name}" not found.`);
         console.log('\nCreate an agent with "town create" or list agents with "town list"');
         process.exit(1);
     }
-    const agentPath = getAgentPath(name);
     const binPath = join(agentPath, "bin.ts");
     // Create logger with agent directory as logs location
     const logger = createLogger("cli", "debug", {
@@ -200,8 +213,8 @@ export async function runCommand(options) {
                 PORT: availablePort.toString(),
             },
         });
-        // Start the GUI dev server
-        const guiProcess = spawn("bun", ["run", "dev"], {
+        // Start the GUI dev server (no package.json, run vite directly)
+        const guiProcess = spawn("bunx", ["vite"], {
             cwd: guiPath,
             stdio: ["ignore", "pipe", "pipe"], // Pipe stdout/stderr for capture
             env: {

package/dist/index.js

@@ -1,19 +1,20 @@
 #!/usr/bin/env bun
+import { join } from "node:path";
 import { argument, command, constant, flag, multiple, object, option, optional, or, } from "@optique/core";
 import { message } from "@optique/core/message";
 import { integer, string } from "@optique/core/valueparser";
 import { run } from "@optique/run";
+import { initForClaudeCode } from "@townco/agent/scaffold";
+import { isInsideTownProject } from "@townco/agent/storage";
 import { createSecret, deleteSecret, genenv, listSecrets, } from "@townco/secret";
 import inquirer from "inquirer";
 import { match } from "ts-pattern";
 import { configureCommand } from "./commands/configure.js";
 import { createCommand } from "./commands/create.js";
+import { createProjectCommand } from "./commands/create-project.js";
 import { deleteCommand } from "./commands/delete.js";
 import { editCommand } from "./commands/edit.js";
 import { listCommand } from "./commands/list.js";
-import { runMCPAdd } from "./commands/mcp-add.js";
-import { runMCPList } from "./commands/mcp-list.js";
-import { runMCPRemove } from "./commands/mcp-remove.js";
 import { runCommand } from "./commands/run.js";
 import { runToolAdd } from "./commands/tool-add.js";
 import { runToolList } from "./commands/tool-list.js";
@@ -41,7 +42,11 @@ const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy
     model: optional(option("-m", "--model", string())),
     tools: multiple(option("-t", "--tool", string())),
     systemPrompt: optional(option("-p", "--prompt", string())),
-}), { brief: message `Create a new agent.` }), command("list", constant("list"), { brief: message `List all agents.` }), command("run", object({
+    init: optional(option("--init", string())),
+    claude: optional(flag("--claude")),
+}), {
+    brief: message `Create a new agent or project (with --init <path>). Use --claude to add Claude Code integration.`,
+}), command("list", constant("list"), { brief: message `List all agents.` }), command("run", object({
     command: constant("run"),
     name: argument(string({ metavar: "NAME" })),
     http: optional(flag("--http")),
@@ -53,20 +58,7 @@ const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy
 }), { brief: message `Edit an agent.` }), command("delete", object({
     command: constant("delete"),
     name: argument(string({ metavar: "NAME" })),
-}), { brief: message `Delete an agent.` }), command("mcp", object({
-    command: constant("mcp"),
-    subcommand: or(command("add", object({
-        action: constant("add"),
-        name: optional(option("-n", "--name", string())),
-        url: optional(option("-u", "--url", string())),
-        command: optional(option("-c", "--command", string())),
-        args: multiple(option("-a", "--arg", string())),
-    }), { brief: message `Add a new MCP server.` }), command("list", constant("list"), {
-        brief: message `List all configured MCP servers.`,
-    }), command("remove", constant("remove"), {
-        brief: message `Remove an MCP server.`,
-    })),
-}), { brief: message `Manage MCP (Model Context Protocol) servers.` }), command("tool", object({
+}), { brief: message `Delete an agent.` }), command("tool", object({
     command: constant("tool"),
     subcommand: or(command("add", object({
         action: constant("add"),
@@ -109,15 +101,76 @@ async function main(parser, meta) {
         .with("configure", async () => {
         await configureCommand();
     })
-        .with({ command: "create" }, async ({ name, model, tools, systemPrompt }) => {
-        // Create command starts a long-running Ink session
-        // Only pass defined properties to satisfy exactOptionalPropertyTypes
-        await createCommand({
-            ...(name !== undefined && { name }),
-            ...(model !== undefined && { model }),
-            ...(tools.length > 0 && { tools }),
-            ...(systemPrompt !== undefined && { systemPrompt }),
-        });
+        .with({ command: "create" }, async ({ name, model, tools, systemPrompt, init, claude }) => {
+        // Handle --claude flag (initialize .claude in existing project)
+        if (claude === true) {
+            if (init !== null && init !== undefined) {
+                console.error("Error: --claude flag is redundant with --init (projects include .claude by default)");
+                process.exit(1);
+            }
+            // Check if we're in a Town project
+            const projectRoot = await isInsideTownProject();
+            if (projectRoot === null) {
+                console.error("Error: Not inside a Town project. Use 'town create --init <path>' to create a new project.");
+                process.exit(1);
+            }
+            // Initialize .claude directory only
+            await initForClaudeCode(projectRoot);
+            console.log("\n✓ Claude Code workspace initialized successfully!");
+            return;
+        }
+        // Check if --init flag is present for project scaffolding
+        if (init !== null && init !== undefined) {
+            // Project mode - scaffold a standalone project
+            await createProjectCommand({
+                path: init,
+            });
+        }
+        else {
+            // Check if we're inside a Town project
+            const projectRoot = await isInsideTownProject();
+            if (projectRoot === null) {
+                // Not in a project - prompt user to initialize
+                const answer = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "initProject",
+                        message: "Not inside a Town project. Initialize project in current directory?",
+                        default: true,
+                    },
+                ]);
+                if (answer.initProject) {
+                    // Initialize project first
+                    await createProjectCommand({ path: process.cwd() });
+                    // Then create agent
+                    await createCommand({
+                        ...(name !== undefined && { name }),
+                        ...(model !== undefined && { model }),
+                        ...(tools.length > 0 && { tools }),
+                        ...(systemPrompt !== undefined && { systemPrompt }),
+                        agentsDir: join(process.cwd(), "agents"),
+                    });
+                }
+                else {
+                    // User declined
+                    console.log("\nPlease run 'town create' inside a project directory, or run:\n" +
+                        "  town create --init <path>\n" +
+                        "to create a project.");
+                    process.exit(1);
+                }
+            }
+            else {
+                // Agent mode - create agent in existing project
+                // Create command starts a long-running Ink session
+                await createCommand({
+                    ...(name !== undefined && { name }),
+                    ...(model !== undefined && { model }),
+                    ...(tools.length > 0 && { tools }),
+                    ...(systemPrompt !== undefined && { systemPrompt }),
+                    agentsDir: join(projectRoot, "agents"),
+                });
+            }
+        }
     })
         .with("list", async () => {
         await listCommand();
@@ -138,20 +191,6 @@ async function main(parser, meta) {
     })
         .with({ command: "delete" }, async ({ name }) => {
         await deleteCommand(name);
-    })
-        .with({ command: "mcp" }, async ({ subcommand }) => {
-        await match(subcommand)
-            .with({ action: "add" }, async ({ name, url, command, args }) => {
-            await runMCPAdd({
-                ...(name !== undefined && { name }),
-                ...(url !== undefined && { url }),
-                ...(command !== undefined && { command }),
-                ...(args.length > 0 && { args }),
-            });
-        })
-            .with("list", async () => await runMCPList())
-            .with("remove", async () => await runMCPRemove())
-            .exhaustive();
     })
         .with({ command: "tool" }, async ({ subcommand }) => {
         await match(subcommand)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -18,16 +18,16 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.14",
+    "@townco/tsconfig": "0.1.16",
     "@types/bun": "^1.3.1",
     "@types/react": "^19.2.2"
   },
   "dependencies": {
     "@optique/core": "^0.6.2",
     "@optique/run": "^0.6.2",
-    "@townco/agent": "0.1.22",
-    "@townco/secret": "0.1.17",
-    "@townco/ui": "0.1.17",
+    "@townco/agent": "0.1.24",
+    "@townco/secret": "0.1.19",
+    "@townco/ui": "0.1.19",
     "@types/inquirer": "^9.0.9",
     "ink": "^6.4.0",
     "ink-text-input": "^6.0.0",

package/dist/commands/mcp-add.d.ts

@@ -1,14 +0,0 @@
-interface MCPAddProps {
-	name?: string;
-	url?: string;
-	command?: string;
-	args?: readonly string[];
-}
-declare function MCPAddApp({
-	name: initialName,
-	url: initialUrl,
-	command: initialCommand,
-	args: initialArgs,
-}: MCPAddProps): import("react/jsx-runtime").JSX.Element | null;
-export default MCPAddApp;
-export declare function runMCPAdd(props?: MCPAddProps): Promise<void>;