@townco/agent 0.1.21 → 0.1.23

package/dist/scaffold/index.js

@@ -1,52 +1,47 @@
 import { spawn } from "node:child_process";
-import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { mkdir, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { agentExists, ensureAgentsDir, getAgentPath } from "../storage";
-import { generateAgentJson, generateBinTs, generateEnvExample, generateGitignore, generateIndexTs, generatePackageJson, generateReadme, generateTsConfig, getTemplateVars, } from "../templates";
+import { generateBinTs, generateIndexTs, getTemplateVars } from "../templates";
 import { copyGuiApp } from "./copy-gui";
 import { copyTuiApp } from "./copy-tui";
 /**
  * Scaffold a new agent package
  */
 export async function scaffoldAgent(options) {
-    const { name, definition, overwrite = false, includeGui = true, includeTui = true, } = options;
+    const { name, definition, overwrite = false, includeGui = true, includeTui = true, agentsDir, } = options;
     try {
-        // Ensure base directory exists
-        await ensureAgentsDir();
+        // Ensure the agents directory exists
+        await mkdir(agentsDir, { recursive: true });
         // Check if agent already exists
-        const exists = await agentExists(name);
-        if (exists && !overwrite) {
-            return {
-                success: false,
-                path: getAgentPath(name),
-                error: `Agent "${name}" already exists. Use overwrite option to replace it.`,
-            };
+        const agentPath = join(agentsDir, name);
+        try {
+            const agentStat = await stat(agentPath);
+            if (agentStat.isDirectory() && !overwrite) {
+                return {
+                    success: false,
+                    path: agentPath,
+                    error: `Agent "${name}" already exists. Use overwrite option to replace it.`,
+                };
+            }
+        }
+        catch {
+            // Agent doesn't exist, which is fine
         }
-        const agentPath = getAgentPath(name);
         // Create the agent directory
         await mkdir(agentPath, { recursive: true });
         const vars = getTemplateVars(name, definition);
-        // Generate all template files
+        // Generate template files - just the essentials
         const files = [
-            { path: "package.json", content: generatePackageJson(vars) },
-            { path: "agent.json", content: generateAgentJson(vars) },
-            { path: "index.ts", content: generateIndexTs() },
+            { path: "index.ts", content: await generateIndexTs(vars) },
             { path: "bin.ts", content: generateBinTs(), executable: true },
-            { path: "tsconfig.json", content: generateTsConfig() },
-            { path: "README.md", content: generateReadme(vars) },
-            { path: ".gitignore", content: generateGitignore() },
         ];
-        // Add .env.example if needed
-        const envExample = generateEnvExample(vars);
-        if (envExample) {
-            files.push({ path: ".env.example", content: envExample });
-        }
         // Write all files
         for (const file of files) {
             const filePath = join(agentPath, file.path);
             await writeFile(filePath, file.content, "utf-8");
-            // Make executable if needed
-            if (file.executable) {
+            // Make executable if specified
+            if ("executable" in file && file.executable) {
+                const { chmod } = await import("node:fs/promises");
                 await chmod(filePath, 0o755);
             }
         }
@@ -64,8 +59,6 @@ export async function scaffoldAgent(options) {
             const tuiPath = join(agentPath, "tui");
             await runBunInstall(tuiPath);
         }
-        // Run bun install in agent root to fetch dependencies from npm
-        await runBunInstall(agentPath);
         return {
             success: true,
             path: agentPath,
@@ -74,7 +67,7 @@ export async function scaffoldAgent(options) {
     catch (error) {
         return {
             success: false,
-            path: getAgentPath(name),
+            path: join(agentsDir, name),
             error: error instanceof Error ? error.message : String(error),
         };
     }
@@ -101,3 +94,5 @@ function runBunInstall(agentPath) {
         });
     });
 }
+// Export project scaffolding
+export { scaffoldProject } from "./project-scaffold";

package/dist/scaffold/project-scaffold.d.ts

@@ -0,0 +1,12 @@
+export interface ScaffoldProjectOptions {
+    path: string;
+}
+export interface ScaffoldProjectResult {
+    success: boolean;
+    path: string;
+    error?: string;
+}
+/**
+ * Scaffold a new standalone project
+ */
+export declare function scaffoldProject(options: ScaffoldProjectOptions): Promise<ScaffoldProjectResult>;

package/dist/scaffold/project-scaffold.js

@@ -0,0 +1,314 @@
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Generate project package.json
+ */
+function generateProjectPackageJson() {
+    const pkg = {
+        name: "town-agents-project",
+        version: "0.1.0",
+        type: "module",
+        private: true,
+        scripts: {},
+        dependencies: {
+            "@agentclientprotocol/sdk": "^0.5.1",
+            "@optique/core": "^0.6.2",
+            "@optique/run": "^0.6.2",
+            "@radix-ui/react-dialog": "^1.1.15",
+            "@radix-ui/react-label": "^2.1.8",
+            "@radix-ui/react-select": "^2.2.6",
+            "@radix-ui/react-slot": "^1.2.4",
+            "@radix-ui/react-tabs": "^1.1.13",
+            "@townco/ui": "^0.1.0",
+            "@townco/agent": "^0.1.20",
+            "class-variance-authority": "^0.7.1",
+            clsx: "^2.1.1",
+            "ink-text-input": "^6.0.0",
+            ink: "^6.4.0",
+            "lucide-react": "^0.552.0",
+            "react-dom": "^19.2.0",
+            "react-markdown": "^10.1.0",
+            react: "^19.2.0",
+            "remark-gfm": "^4.0.1",
+            "tailwind-merge": "^3.3.1",
+            zod: "^4.1.12",
+            zustand: "^5.0.8",
+        },
+        devDependencies: {
+            "@tailwindcss/postcss": "^4.1.17",
+            "@types/react": "^19.2.2",
+            "@types/react-dom": "^19.2.2",
+            "@vitejs/plugin-react": "^5.1.0",
+            autoprefixer: "^10.4.21",
+            postcss: "^8.5.6",
+            tailwindcss: "^4.1.17",
+            typescript: "^5.9.3",
+            vite: "^7.2.1",
+        },
+    };
+    return JSON.stringify(pkg, null, 2);
+}
+/**
+ * Generate add-two-numbers tool
+ */
+function generateAddTwoNumbersTool() {
+    return `// biome-ignore lint/suspicious/noExplicitAny: .
+export const schema = (z: any) =>
+  z.object({
+    a: z.number().describe("First number"),
+    b: z.number().describe("Second number"),
+  });
+
+export const name = "add_two_numbers";
+export const description = "Add two numbers together and return the result";
+
+export default function addTwoNumbers(input: unknown) {
+  const { a, b } = input as { a: number; b: number };
+  return { result: a + b };
+}
+`;
+}
+/**
+ * Generate project tsconfig.json
+ */
+function generateProjectTsConfig() {
+    const config = {
+        compilerOptions: {
+            target: "ESNext",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            lib: ["ESNext"],
+            outDir: "./dist",
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            allowSyntheticDefaultImports: true,
+        },
+        include: ["agents/**/*.ts", "tools/**/*.ts"],
+        exclude: ["node_modules", "dist"],
+    };
+    return JSON.stringify(config, null, 2);
+}
+/**
+ * Generate project README.md
+ */
+function generateProjectReadme() {
+    return `# Town Agents Project
+
+A standalone project for developing Town agents with custom tools.
+
+## Project Structure
+
+\`\`\`
+.
+├── agents/          # Agent implementations (created with 'town create')
+├── tools/           # Custom tools
+│   └── add-two-numbers.ts  # Example tool
+├── package.json     # Project dependencies
+└── tsconfig.json    # TypeScript configuration
+\`\`\`
+
+## Getting Started
+
+1. Install dependencies (if not already done):
+
+\`\`\`bash
+bun install
+\`\`\`
+
+2. Create your first agent:
+
+\`\`\`bash
+town create
+\`\`\`
+
+This will launch an interactive wizard to create a new agent in the \`agents/\` directory.
+The agent will include GUI and TUI interfaces for interaction.
+
+## Creating Agents
+
+Run \`town create\` inside your project directory to create new agents.
+Each agent will be placed in \`agents/<agent-name>/\` with the following structure:
+
+\`\`\`
+agents/my-agent/
+├── agent.json       # Agent configuration
+├── index.ts         # Agent entry point
+├── gui/             # Web-based GUI interface
+└── tui/             # Terminal UI interface
+\`\`\`
+
+## Running Agents
+
+Each agent can be run in different modes:
+
+\`\`\`bash
+# CLI mode (stdio)
+bun agents/<agent-name>/index.ts stdio
+
+# HTTP server mode
+PORT=3100 bun agents/<agent-name>/index.ts http
+\`\`\`
+
+## Creating Custom Tools
+
+Tools are defined in the \`tools/\` directory. Each tool exports:
+
+- \`schema\`: A Zod schema factory function
+- \`name\`: The tool name
+- \`description\`: Tool description
+- \`default\`: The tool implementation function
+
+Example:
+
+\`\`\`typescript
+export const schema = (z: any) =>
+  z.object({
+    input: z.string(),
+  });
+
+export const name = "my_tool";
+export const description = "My custom tool";
+
+export default function myTool(input: unknown) {
+  // Implementation
+  return { result: "success" };
+}
+\`\`\`
+
+To use a tool in an agent, import it in the agent's \`index.ts\`:
+
+\`\`\`typescript
+import myTool, { name, description, schema } from "../../tools/my-tool.js";
+
+const agent: AgentDefinition = {
+  // ...
+  tools: [
+    {
+      type: "direct",
+      name,
+      description,
+      fn: myTool,
+      schema: schema(z),
+    },
+  ],
+};
+\`\`\`
+`;
+}
+/**
+ * Generate .gitignore
+ */
+function generateProjectGitignore() {
+    return `node_modules
+dist
+.env
+*.log
+`;
+}
+/**
+ * Run bun install
+ */
+function runBunInstall(projectPath) {
+    return new Promise((resolve, reject) => {
+        const bunInstall = spawn("bun", ["install"], {
+            cwd: projectPath,
+            stdio: "pipe",
+        });
+        let stdout = "";
+        let stderr = "";
+        // Capture stdout
+        bunInstall.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        // Capture stderr
+        bunInstall.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        bunInstall.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                // Print captured output on failure
+                if (stdout) {
+                    process.stdout.write(stdout);
+                }
+                if (stderr) {
+                    process.stderr.write(stderr);
+                }
+                reject(new Error(`bun install failed with code ${code}`));
+            }
+        });
+        bunInstall.on("error", (error) => {
+            // Print captured output on error
+            if (stdout) {
+                process.stdout.write(stdout);
+            }
+            if (stderr) {
+                process.stderr.write(stderr);
+            }
+            reject(error);
+        });
+    });
+}
+/**
+ * Scaffold a new standalone project
+ */
+export async function scaffoldProject(options) {
+    const { path: projectPath } = options;
+    try {
+        // Create project root directory
+        await mkdir(projectPath, { recursive: true });
+        // Create agents directory (empty, to be populated by 'town create')
+        const agentsDir = join(projectPath, "agents");
+        await mkdir(agentsDir, { recursive: true });
+        // Create tools directory
+        const toolsDir = join(projectPath, "tools");
+        await mkdir(toolsDir, { recursive: true });
+        // Generate and write files
+        const files = [
+            {
+                path: "package.json",
+                content: generateProjectPackageJson(),
+            },
+            {
+                path: "tsconfig.json",
+                content: generateProjectTsConfig(),
+            },
+            {
+                path: ".gitignore",
+                content: generateProjectGitignore(),
+            },
+            {
+                path: "README.md",
+                content: generateProjectReadme(),
+            },
+            {
+                path: join("tools", "add-two-numbers.ts"),
+                content: generateAddTwoNumbersTool(),
+            },
+        ];
+        // Write all files
+        for (const file of files) {
+            const filePath = join(projectPath, file.path);
+            await writeFile(filePath, file.content, "utf-8");
+        }
+        // Run bun install
+        await runBunInstall(projectPath);
+        return {
+            success: true,
+            path: projectPath,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            path: projectPath,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/storage/index.d.ts

@@ -22,3 +22,8 @@ export declare function deleteAgent(name: string): Promise<void>;
  * Ensure the agents directory exists
  */
 export declare function ensureAgentsDir(): Promise<void>;
+/**
+ * Check if we're inside a Town project by looking for project markers
+ * Returns the project root path if found, null otherwise
+ */
+export declare function isInsideTownProject(startPath?: string): Promise<string | null>;

package/dist/storage/index.js

@@ -1,57 +1,93 @@
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
-
+import { dirname, join } from "node:path";
 const AGENTS_DIR = join(homedir(), ".config", "town", "agents");
 /**
  * Get the base directory where all agents are stored
  */
 export function getAgentsDir() {
-	return AGENTS_DIR;
+    return AGENTS_DIR;
 }
 /**
  * Get the directory path for a specific agent
  */
 export function getAgentPath(name) {
-	return join(AGENTS_DIR, name);
+    return join(AGENTS_DIR, name);
 }
 /**
  * Check if an agent exists
  */
 export async function agentExists(name) {
-	try {
-		const agentPath = getAgentPath(name);
-		const stats = await stat(agentPath);
-		return stats.isDirectory();
-	} catch {
-		return false;
-	}
+    try {
+        const agentPath = getAgentPath(name);
+        const stats = await stat(agentPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * List all created agents
  */
 export async function listAgents() {
-	try {
-		await mkdir(AGENTS_DIR, { recursive: true });
-		const entries = await readdir(AGENTS_DIR, { withFileTypes: true });
-		return entries
-			.filter((entry) => entry.isDirectory())
-			.map((entry) => entry.name);
-	} catch (error) {
-		console.error("Error listing agents:", error);
-		return [];
-	}
+    try {
+        await mkdir(AGENTS_DIR, { recursive: true });
+        const entries = await readdir(AGENTS_DIR, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch (error) {
+        console.error("Error listing agents:", error);
+        return [];
+    }
 }
 /**
  * Delete an agent
  */
 export async function deleteAgent(name) {
-	const agentPath = getAgentPath(name);
-	await rm(agentPath, { recursive: true, force: true });
+    const agentPath = getAgentPath(name);
+    await rm(agentPath, { recursive: true, force: true });
 }
 /**
  * Ensure the agents directory exists
  */
 export async function ensureAgentsDir() {
-	await mkdir(AGENTS_DIR, { recursive: true });
+    await mkdir(AGENTS_DIR, { recursive: true });
+}
+/**
+ * Check if we're inside a Town project by looking for project markers
+ * Returns the project root path if found, null otherwise
+ */
+export async function isInsideTownProject(startPath = process.cwd()) {
+    let currentPath = startPath;
+    while (true) {
+        try {
+            // Check if this is a Town project by looking for:
+            // 1. agents/ directory exists
+            // (this is very naive right now)
+            const agentsDir = join(currentPath, "agents");
+            try {
+                const agentsDirStat = await stat(agentsDir);
+                if (agentsDirStat.isDirectory()) {
+                    return currentPath;
+                }
+            }
+            catch {
+                // agents/ directory doesn't exist, continue searching
+            }
+        }
+        catch {
+            // package.json doesn't exist or can't be read, continue searching
+        }
+        // Move up one directory
+        const parentPath = dirname(currentPath);
+        if (parentPath === currentPath) {
+            // Reached the filesystem root
+            break;
+        }
+        currentPath = parentPath;
+    }
+    return null;
 }

package/dist/templates/index.d.ts

@@ -8,14 +8,19 @@ export interface TemplateVars {
     } | {
         type: "filesystem";
         working_directory?: string | undefined;
+    } | {
+        type: "direct";
+        name: string;
+        description: string;
+        fn: any;
+        schema: unknown;
     }>;
     systemPrompt: string | null;
     hasWebSearch: boolean;
 }
 export declare function getTemplateVars(name: string, definition: AgentDefinition): TemplateVars;
 export declare function generatePackageJson(vars: TemplateVars): string;
-export declare function generateIndexTs(): string;
-export declare function generateAgentJson(vars: TemplateVars): string;
+export declare function generateIndexTs(vars: TemplateVars): Promise<string>;
 export declare function generateBinTs(): string;
 export declare function generateGitignore(): string;
 export declare function generateTsConfig(): string;

package/dist/templates/index.js

@@ -1,3 +1,4 @@
+import * as prettier from "prettier";
 export function getTemplateVars(name, definition) {
     const tools = definition.tools ?? [];
     return {
@@ -42,15 +43,17 @@ export function generatePackageJson(vars) {
     };
     return JSON.stringify(pkg, null, 2);
 }
-export function generateIndexTs() {
-    return `import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { makeHttpTransport, makeStdioTransport } from "@townco/agent/acp-server";
+export async function generateIndexTs(vars) {
+    const agentDef = {
+        model: vars.model,
+        systemPrompt: vars.systemPrompt,
+        tools: vars.tools,
+    };
+    return prettier.format(`import { makeHttpTransport, makeStdioTransport } from "@townco/agent/acp-server";
 import type { AgentDefinition } from "@townco/agent/definition";
 
 // Load agent definition from JSON file
-const configPath = join(import.meta.dir, "agent.json");
-const agent: AgentDefinition = JSON.parse(readFileSync(configPath, "utf-8"));
+const agent: AgentDefinition = ${JSON.stringify(agentDef)};
 
 const transport = process.argv[2] || "stdio";
 
@@ -62,19 +65,11 @@ if (transport === "http") {
 	console.error(\`Invalid transport: \${transport}\`);
 	process.exit(1);
 }
-`;
-}
-export function generateAgentJson(vars) {
-    const agentDef = {
-        model: vars.model,
-        systemPrompt: vars.systemPrompt,
-        tools: vars.tools,
-    };
-    return JSON.stringify(agentDef, null, 2);
+`, { parser: "typescript" });
 }
 export function generateBinTs() {
     return `#!/usr/bin/env bun
-import "./index.js";
+import "./index.ts";
 `;
 }
 export function generateGitignore() {
@@ -113,6 +108,8 @@ export function generateReadme(vars) {
                 return tool.modulePath;
             if (tool.type === "filesystem")
                 return `filesystem${tool.working_directory ? ` (${tool.working_directory})` : ""}`;
+            if (tool.type === "direct")
+                return tool.name;
             return "";
         })
             .join(", ")