@townco/cli 0.1.21 → 0.1.23

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/mcp-add.d.ts

@@ -1,14 +1,9 @@
 interface MCPAddProps {
-	name?: string;
-	url?: string;
-	command?: string;
-	args?: readonly string[];
+    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;
+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>;

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/commands/tool-stub.d.ts

@@ -0,0 +1,6 @@
+interface ToolStubProps {
+    name?: string;
+}
+declare function ToolStubApp({ name: initialName }: ToolStubProps): import("react/jsx-runtime").JSX.Element | null;
+export default ToolStubApp;
+export declare function runToolStub(props?: ToolStubProps): Promise<void>;

package/dist/commands/tool-stub.js

@@ -0,0 +1,376 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { spawn } from "node:child_process";
+import { copyFileSync, existsSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getAgentPath, listAgents } from "@townco/agent/storage";
+import { MultiSelect } from "@townco/ui/tui";
+import { Box, render, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useEffect, useState } from "react";
+import { ensureToolsDir, getToolsDir, saveToolConfig, toolConfigExists, } from "../lib/tool-storage";
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Normalize a tool name to kebab-case for use as a filename
+ */
+function normalizeToolName(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Convert kebab-case or snake_case to camelCase for function names
+ */
+function toCamelCase(str) {
+    return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase());
+}
+/**
+ * Convert a name to snake_case for the tool name export
+ */
+function toSnakeCase(str) {
+    return str
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+/**
+ * Generate the stub template content
+ */
+function generateStubTemplate(toolName) {
+    const snakeCaseName = toolName ? toSnakeCase(toolName) : "tool_name";
+    const camelCaseName = toolName ? toCamelCase(toolName) : "toolName";
+    const description = toolName
+        ? `Describe what ${toolName} does here`
+        : "Describe what your tool does here";
+    return `// biome-ignore lint/suspicious/noExplicitAny: .
+export const schema = (z: any) =>
+  z.object({
+    // Define your input parameters here
+    // Example: message: z.string().describe("The message to process"),
+    input: z.string().optional(),
+  });
+
+export const name = "${snakeCaseName}";
+export const description = "${description}";
+
+export default function ${camelCaseName}(_input: unknown) {
+  // TODO: Implement your tool logic here
+
+  return "result";
+}
+`;
+}
+/**
+ * Open a file in the user's editor and wait for it to close
+ */
+async function openInEditor(filePath) {
+    return new Promise((resolve, reject) => {
+        // Get editor from environment, fallback to vi
+        const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+        // Parse editor command (might include args like "code --wait")
+        const editorParts = editor.split(" ");
+        const editorCommand = editorParts[0] || "vi";
+        const editorArgs = [...editorParts.slice(1), filePath];
+        const child = spawn(editorCommand, editorArgs, {
+            stdio: "inherit",
+        });
+        child.on("exit", (code) => {
+            if (code === 0 || code === null) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Editor exited with code ${code}`));
+            }
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+    });
+}
+function TextInputStage({ title, value, onChange, onSubmit, onCancel, placeholder, }) {
+    useInput((_input, key) => {
+        if (key.escape) {
+            onCancel();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: title }) }), _jsxs(Box, { children: [_jsxs(Text, { children: [">", " "] }), _jsx(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit, ...(placeholder && { placeholder }) })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Continue \u2022 Esc: Back" }) })] }));
+}
+function NameInputStage({ value, onChange, onNext, onBack, }) {
+    const [localError, setLocalError] = useState(null);
+    const handleSubmit = () => {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return;
+        }
+        // Check for duplicate
+        if (toolConfigExists(trimmed)) {
+            setLocalError(`Tool "${trimmed}" already exists`);
+            return;
+        }
+        onNext(trimmed);
+    };
+    const handleChange = (newValue) => {
+        if (localError) {
+            setLocalError(null);
+        }
+        onChange(newValue);
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TextInputStage, { title: "Enter tool name:", value: value, onChange: handleChange, onSubmit: handleSubmit, onCancel: onBack, placeholder: "my-custom-tool" }), localError && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["\u274C ", localError] }) }))] }));
+}
+function NoAgentsMessage({ onNext }) {
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            onNext();
+        }, 1000);
+        return () => clearTimeout(timer);
+    }, [onNext]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "No agents found. Tool will be saved globally." }), _jsx(Text, { dimColor: true, children: "You can attach it to agents later." })] }));
+}
+function AgentSelectionStage({ selectedAgents, onSelectedAgentsChange, onNext, onBack, }) {
+    const [availableAgents, setAvailableAgents] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    useEffect(() => {
+        // Fetch available agents
+        const fetchAgents = async () => {
+            try {
+                const agents = await listAgents();
+                setAvailableAgents(agents);
+            }
+            catch (error) {
+                console.error("Error fetching agents:", error);
+                setAvailableAgents([]);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        fetchAgents();
+    }, []);
+    // If still loading, show loading message
+    if (isLoading) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "Loading agents..." }) }));
+    }
+    // If no agents available, show info message and auto-proceed
+    if (availableAgents.length === 0) {
+        return _jsx(NoAgentsMessage, { onNext: onNext });
+    }
+    // Show agent selection UI
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Register tool with agents (optional):" }) }), _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Select which agents should have access to this tool." }), _jsx(Text, { dimColor: true, children: "You can skip this step and register agents later." })] }), _jsx(MultiSelect, { options: availableAgents.map((agent) => ({
+                    label: agent,
+                    value: agent,
+                })), selected: selectedAgents, onChange: onSelectedAgentsChange, onSubmit: onNext, onCancel: onBack })] }));
+}
+function DoneStage({ config, status, error, attachedAgents }) {
+    const { exit } = useApp();
+    useEffect(() => {
+        if (status === "done") {
+            setImmediate(() => {
+                exit();
+            });
+        }
+    }, [status, exit]);
+    if (status === "saving") {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "\u23F3 Saving tool configuration..." }) }));
+    }
+    if (status === "error") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u274C Error saving tool" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: error }) })] }));
+    }
+    if (status === "done") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", children: "\u2705 Tool saved successfully!" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: ["Name: ", config.name] }), _jsxs(Text, { dimColor: true, children: ["Path: ", config.path] })] }), attachedAgents.length > 0 && (_jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsxs(Text, { dimColor: true, children: ["Registered with agents: ", attachedAgents.join(", ")] }) }))] }));
+    }
+    return null;
+}
+// ============================================================================
+// Main Component
+// ============================================================================
+function ToolStubApp({ name: initialName }) {
+    const { exit } = useApp();
+    const [stage, setStage] = useState("name");
+    const [config, setConfig] = useState({});
+    const [nameInput, setNameInput] = useState(initialName || "");
+    const [saveStatus, setSaveStatus] = useState("pending");
+    const [saveError, setSaveError] = useState(null);
+    const [selectedAgents, setSelectedAgents] = useState([]);
+    const [tempFilePath, setTempFilePath] = useState(null);
+    const [editorOpened, setEditorOpened] = useState(false);
+    // On mount, create temp file and open editor
+    useEffect(() => {
+        if (editorOpened)
+            return;
+        const setupAndOpenEditor = async () => {
+            try {
+                // Generate temp file path
+                const tempFile = join(tmpdir(), `town-tool-${Date.now()}.ts`);
+                setTempFilePath(tempFile);
+                // Generate and write stub template
+                const stubContent = generateStubTemplate(initialName);
+                writeFileSync(tempFile, stubContent, "utf-8");
+                // Open in editor
+                await openInEditor(tempFile);
+                // After editor closes, move to name input stage
+                setEditorOpened(true);
+            }
+            catch (error) {
+                setSaveStatus("error");
+                setSaveError(`Failed to open editor: ${error instanceof Error ? error.message : String(error)}`);
+                setStage("done");
+            }
+        };
+        setupAndOpenEditor();
+    }, [initialName, editorOpened]);
+    const handleSave = (toolName, agentsToAttach) => {
+        setSaveStatus("saving");
+        try {
+            if (!tempFilePath) {
+                setSaveStatus("error");
+                setSaveError("Temp file path not found");
+                return;
+            }
+            // Check if temp file still exists
+            if (!existsSync(tempFilePath)) {
+                setSaveStatus("error");
+                setSaveError("Temp file was deleted");
+                return;
+            }
+            // Read the edited content
+            const editedContent = readFileSync(tempFilePath, "utf-8");
+            // Ensure tools directory exists
+            ensureToolsDir();
+            // Normalize the tool name for the filename
+            const normalizedName = normalizeToolName(toolName);
+            const toolsDir = getToolsDir();
+            const targetPath = join(toolsDir, `${normalizedName}.ts`);
+            // Write the edited content to the target path
+            try {
+                writeFileSync(targetPath, editedContent, "utf-8");
+            }
+            catch (error) {
+                setSaveStatus("error");
+                setSaveError(`Failed to save file: ${error instanceof Error ? error.message : String(error)}`);
+                return;
+            }
+            // Create tool config
+            const toolConfig = {
+                name: toolName,
+                path: targetPath,
+            };
+            // Save to global tool storage
+            saveToolConfig(toolConfig);
+            // Update selected agents
+            for (const agentName of agentsToAttach) {
+                try {
+                    const agentPath = getAgentPath(agentName);
+                    const agentJsonPath = join(agentPath, "agent.json");
+                    // Read existing agent.json
+                    const agentJsonContent = readFileSync(agentJsonPath, "utf-8");
+                    const agentDef = JSON.parse(agentJsonContent);
+                    // Add tool to tools array (create array if doesn't exist)
+                    if (!agentDef.tools) {
+                        agentDef.tools = [];
+                    }
+                    // Create custom tool object
+                    const customTool = {
+                        type: "custom",
+                        modulePath: targetPath,
+                    };
+                    // Check if this tool is already in the agent's config
+                    const existingIndex = agentDef.tools.findIndex((tool) => typeof tool === "object" &&
+                        tool !== null &&
+                        "type" in tool &&
+                        tool.type === "custom" &&
+                        "modulePath" in tool &&
+                        tool.modulePath === targetPath);
+                    if (existingIndex >= 0) {
+                        // Update existing config
+                        agentDef.tools[existingIndex] = customTool;
+                    }
+                    else {
+                        // Add new config
+                        agentDef.tools.push(customTool);
+                    }
+                    // Write back to agent.json
+                    writeFileSync(agentJsonPath, JSON.stringify(agentDef, null, 2));
+                }
+                catch (error) {
+                    console.error(`Error updating agent ${agentName}:`, error);
+                    // Continue with other agents even if one fails
+                }
+            }
+            // Clean up temp file
+            try {
+                unlinkSync(tempFilePath);
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+            setConfig(toolConfig);
+            setSaveStatus("done");
+        }
+        catch (error) {
+            setSaveStatus("error");
+            setSaveError(error instanceof Error ? error.message : "Unknown error occurred");
+        }
+    };
+    // Wait for editor to open and close before showing UI
+    if (!editorOpened) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "Opening editor..." }) }));
+    }
+    // If there was an error during editor setup, show done stage with error
+    if (saveStatus === "error" && stage === "done") {
+        return (_jsx(DoneStage, { config: config, status: saveStatus, error: saveError, attachedAgents: selectedAgents }));
+    }
+    // Name input stage
+    if (stage === "name") {
+        return (_jsx(NameInputStage, { value: nameInput, onChange: setNameInput, onNext: (name) => {
+                setConfig({ ...config, name });
+                setStage("agentSelection");
+            }, onBack: () => {
+                // Clean up temp file
+                if (tempFilePath) {
+                    try {
+                        unlinkSync(tempFilePath);
+                    }
+                    catch (error) {
+                        // Ignore cleanup errors
+                    }
+                }
+                exit();
+            } }));
+    }
+    // Agent selection stage
+    if (stage === "agentSelection") {
+        return (_jsx(AgentSelectionStage, { selectedAgents: selectedAgents, onSelectedAgentsChange: setSelectedAgents, onNext: () => {
+                if (!config.name) {
+                    setSaveStatus("error");
+                    setSaveError("Tool name is required");
+                    setStage("done");
+                    return;
+                }
+                handleSave(config.name, selectedAgents);
+                setStage("done");
+            }, onBack: () => setStage("name") }));
+    }
+    // Done stage
+    if (stage === "done") {
+        return (_jsx(DoneStage, { config: config, status: saveStatus, error: saveError, attachedAgents: selectedAgents }));
+    }
+    return null;
+}
+// ============================================================================
+// Export and Runner
+// ============================================================================
+export default ToolStubApp;
+export async function runToolStub(props = {}) {
+    // Set stdin to raw mode to capture input
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    const { waitUntilExit } = render(_jsx(ToolStubApp, { ...props }));
+    // Wait for the app to exit before returning
+    await waitUntilExit();
+}

package/dist/index.js

@@ -1,13 +1,16 @@
 #!/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 { 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";
@@ -41,7 +44,8 @@ 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())),
+}), { brief: message `Create a new agent or project (with --init <path>).` }), command("list", constant("list"), { brief: message `List all agents.` }), command("run", object({
     command: constant("run"),
     name: argument(string({ metavar: "NAME" })),
     http: optional(flag("--http")),
@@ -109,15 +113,59 @@ 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 }) => {
+        // 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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -18,16 +18,16 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.13",
+    "@townco/tsconfig": "0.1.15",
     "@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.21",
-    "@townco/secret": "0.1.16",
-    "@townco/ui": "0.1.16",
+    "@townco/agent": "0.1.23",
+    "@townco/secret": "0.1.18",
+    "@townco/ui": "0.1.18",
     "@types/inquirer": "^9.0.9",
     "ink": "^6.4.0",
     "ink-text-input": "^6.0.0",