@townco/agent 0.1.0

package/dist/scaffold/index.js

@@ -0,0 +1,98 @@
+import { spawn } from "node:child_process";
+import { chmod, mkdir, 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 { bundleAgentDependencies } from "./bundle";
+import { copyGuiApp } from "./copy-gui";
+/**
+ * Scaffold a new agent package
+ */
+export async function scaffoldAgent(options) {
+    const { name, definition, overwrite = false, includeGui = true } = options;
+    try {
+        // Ensure base directory exists
+        await ensureAgentsDir();
+        // 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 = getAgentPath(name);
+        // Create the agent directory
+        await mkdir(agentPath, { recursive: true });
+        const vars = getTemplateVars(name, definition);
+        // Generate all template files
+        const files = [
+            { path: "package.json", content: generatePackageJson(vars) },
+            { path: "agent.json", content: generateAgentJson(vars) },
+            { path: "index.ts", content: generateIndexTs() },
+            { 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) {
+                await chmod(filePath, 0o755);
+            }
+        }
+        // Bundle agent dependencies (copy lib files)
+        await bundleAgentDependencies(agentPath);
+        // Copy GUI app if requested
+        if (includeGui) {
+            await copyGuiApp(agentPath);
+            // Run bun install in the GUI directory
+            const guiPath = join(agentPath, "gui");
+            await runBunInstall(guiPath);
+        }
+        // Run bun install in agent root
+        await runBunInstall(agentPath);
+        return {
+            success: true,
+            path: agentPath,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            path: getAgentPath(name),
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Run bun install in the agent directory
+ */
+function runBunInstall(agentPath) {
+    return new Promise((resolve, reject) => {
+        const bunInstall = spawn("bun", ["install"], {
+            cwd: agentPath,
+            stdio: "ignore",
+        });
+        bunInstall.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`bun install failed with code ${code}`));
+            }
+        });
+        bunInstall.on("error", (error) => {
+            reject(error);
+        });
+    });
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Get the base directory where all agents are stored
+ */
+export declare function getAgentsDir(): string;
+/**
+ * Get the directory path for a specific agent
+ */
+export declare function getAgentPath(name: string): string;
+/**
+ * Check if an agent exists
+ */
+export declare function agentExists(name: string): Promise<boolean>;
+/**
+ * List all created agents
+ */
+export declare function listAgents(): Promise<string[]>;
+/**
+ * Delete an agent
+ */
+export declare function deleteAgent(name: string): Promise<void>;
+/**
+ * Ensure the agents directory exists
+ */
+export declare function ensureAgentsDir(): Promise<void>;

package/dist/storage/index.js

@@ -0,0 +1,58 @@
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { 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;
+}
+/**
+ * Get the directory path for a specific agent
+ */
+export function getAgentPath(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;
+    }
+}
+/**
+ * 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 [];
+    }
+}
+/**
+ * Delete an agent
+ */
+export async function deleteAgent(name) {
+    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 });
+}

package/dist/templates/index.d.ts

@@ -0,0 +1,17 @@
+import type { AgentDefinition } from "../definition";
+export interface TemplateVars {
+    name: string;
+    model: string;
+    tools: string[];
+    systemPrompt: string | null;
+    hasWebSearch: boolean;
+}
+export declare function getTemplateVars(name: string, definition: AgentDefinition): TemplateVars;
+export declare function generatePackageJson(vars: TemplateVars, useLocalDeps?: boolean): string;
+export declare function generateIndexTs(): string;
+export declare function generateAgentJson(vars: TemplateVars): string;
+export declare function generateBinTs(): string;
+export declare function generateGitignore(): string;
+export declare function generateTsConfig(): string;
+export declare function generateReadme(vars: TemplateVars): string;
+export declare function generateEnvExample(vars: TemplateVars): string | null;

package/dist/templates/index.js

@@ -0,0 +1,173 @@
+export function getTemplateVars(name, definition) {
+    const tools = definition.tools || [];
+    return {
+        name,
+        model: definition.model,
+        tools,
+        systemPrompt: definition.systemPrompt,
+        hasWebSearch: tools.includes("web_search"),
+    };
+}
+export function generatePackageJson(vars, useLocalDeps = true) {
+    // For local development, use link: protocol to reference monorepo packages
+    // After npm publish, users will use the published versions
+    const dependencies = useLocalDeps
+        ? {
+            "@townco/agent": "link:../../../../agent_hub/packages/agent",
+            "@townco/ui": "link:../../../../agent_hub/packages/ui",
+        }
+        : {
+            "@townco/agent": "^0.1.0",
+            "@townco/ui": "^0.1.0",
+        };
+    const pkg = {
+        name: `@townco/agent-${vars.name}`,
+        version: "0.0.1",
+        type: "module",
+        module: "index.ts",
+        bin: {
+            [`town-agent-${vars.name}`]: "./bin.ts",
+        },
+        scripts: {
+            build: "tsc",
+            check: "tsc --noEmit",
+            start: "bun index.ts stdio",
+            "start-http": "PORT=3100 bun index.ts http",
+        },
+        dependencies,
+    };
+    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";
+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 transport = process.argv[2] || "stdio";
+
+if (transport === "http") {
+	makeHttpTransport(agent);
+} else if (transport === "stdio") {
+	makeStdioTransport(agent);
+} else {
+	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);
+}
+export function generateBinTs() {
+    return `#!/usr/bin/env bun
+import "./index.js";
+`;
+}
+export function generateGitignore() {
+    return `node_modules
+dist
+.env
+`;
+}
+export function generateTsConfig() {
+    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: ["**/*.ts"],
+        exclude: ["node_modules", "dist"],
+    };
+    return JSON.stringify(config, null, 2);
+}
+export function generateReadme(vars) {
+    const toolsList = vars.tools.length > 0 ? vars.tools.join(", ") : "None";
+    const envVars = vars.hasWebSearch
+        ? "\n- `EXA_API_KEY`: Required for web_search tool"
+        : "";
+    return `# ${vars.name}
+
+Agent created with \`town create\`.
+
+## Configuration
+
+- **Model**: ${vars.model}
+- **Tools**: ${toolsList}
+- **System Prompt**: ${vars.systemPrompt ? "Yes" : "No"}
+
+## Setup
+${envVars ? `\n### Environment Variables\n${envVars}\n` : ""}
+Install dependencies:
+
+\`\`\`bash
+bun install
+\`\`\`
+
+## Usage
+
+### CLI Mode (stdio)
+
+\`\`\`bash
+bun start
+\`\`\`
+
+Or using the executable:
+
+\`\`\`bash
+town-agent-${vars.name}
+\`\`\`
+
+### Server Mode (HTTP)
+
+\`\`\`bash
+bun run start-http
+\`\`\`
+
+The server will start on port 3100 with the following endpoints:
+
+- \`/health\`: Health check
+- \`/rpc\`: Request-response messages
+- \`/events\`: SSE stream for real-time updates
+
+## Development
+
+Type check:
+
+\`\`\`bash
+bun run check
+\`\`\`
+
+Build:
+
+\`\`\`bash
+bun run build
+\`\`\`
+`;
+}
+export function generateEnvExample(vars) {
+    if (!vars.hasWebSearch) {
+        return null;
+    }
+    return `# Required for web_search tool
+EXA_API_KEY=your_exa_api_key_here
+`;
+}

package/dist/test-script.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test-script.js

@@ -0,0 +1,17 @@
+import { LangchainAgent } from "./runner/langchain";
+const agent = new LangchainAgent({
+    model: "claude-sonnet-4-5-20250929",
+    systemPrompt: "You are a helpful assistant.",
+    tools: ["todo_write"],
+});
+for await (const event of agent.invoke({
+    prompt: [
+        {
+            type: "text",
+            text: "Whats the weather in Tokyo?",
+        },
+    ],
+    sessionId: "test-session",
+})) {
+    console.log(event);
+}