@townco/agent 0.1.22 → 0.1.24

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(", ")