@townco/agent 0.1.21 → 0.1.23

package/dist/acp-server/adapter.d.ts

@@ -2,18 +2,14 @@ import * as acp from "@agentclientprotocol/sdk";
 import type { AgentRunner } from "../runner";
 /** Adapts an Agent to speak the ACP protocol */
 export declare class AgentAcpAdapter implements acp.Agent {
-	private connection;
-	private sessions;
-	private agent;
-	constructor(agent: AgentRunner, connection: acp.AgentSideConnection);
-	initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
-	newSession(_params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
-	authenticate(
-		_params: acp.AuthenticateRequest,
-	): Promise<acp.AuthenticateResponse | undefined>;
-	setSessionMode(
-		_params: acp.SetSessionModeRequest,
-	): Promise<acp.SetSessionModeResponse>;
-	prompt(params: acp.PromptRequest): Promise<acp.PromptResponse>;
-	cancel(params: acp.CancelNotification): Promise<void>;
+    private connection;
+    private sessions;
+    private agent;
+    constructor(agent: AgentRunner, connection: acp.AgentSideConnection);
+    initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
+    newSession(_params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
+    authenticate(_params: acp.AuthenticateRequest): Promise<acp.AuthenticateResponse | undefined>;
+    setSessionMode(_params: acp.SetSessionModeRequest): Promise<acp.SetSessionModeResponse>;
+    prompt(params: acp.PromptRequest): Promise<acp.PromptResponse>;
+    cancel(params: acp.CancelNotification): Promise<void>;
 }

package/dist/acp-server/cli.d.ts

@@ -1,5 +1,3 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "../runner";
-export declare function makeStdioTransport(
-	agent: AgentRunner | AgentDefinition,
-): void;
+export declare function makeStdioTransport(agent: AgentRunner | AgentDefinition): void;

package/dist/acp-server/cli.js

@@ -3,13 +3,9 @@ import * as acp from "@agentclientprotocol/sdk";
 import { makeRunnerFromDefinition } from "../runner";
 import { AgentAcpAdapter } from "./adapter";
 export function makeStdioTransport(agent) {
-	const agentRunner =
-		"definition" in agent ? agent : makeRunnerFromDefinition(agent);
-	const input = Writable.toWeb(process.stdout);
-	const output = Readable.toWeb(process.stdin);
-	const stream = acp.ndJsonStream(input, output);
-	new acp.AgentSideConnection(
-		(conn) => new AgentAcpAdapter(agentRunner, conn),
-		stream,
-	);
+    const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
+    const input = Writable.toWeb(process.stdout);
+    const output = Readable.toWeb(process.stdin);
+    const stream = acp.ndJsonStream(input, output);
+    new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn), stream);
 }

package/dist/acp-server/http.d.ts

@@ -1,5 +1,3 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "../runner";
-export declare function makeHttpTransport(
-	agent: AgentRunner | AgentDefinition,
-): void;
+export declare function makeHttpTransport(agent: AgentRunner | AgentDefinition): void;

package/dist/definition/index.d.ts

@@ -22,6 +22,12 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"filesystem">;
         working_directory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"direct">;
+        name: z.ZodString;
+        description: z.ZodString;
+        fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        schema: z.ZodAny;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;

package/dist/definition/index.js

@@ -35,11 +35,20 @@ const FilesystemToolSchema = z.object({
     /** If omitted, defaults to process.cwd() at runtime */
     working_directory: z.string().optional(),
 });
+/** Direct tool configuration schema (for tools imported directly in code). */
+const DirectToolSchema = z.object({
+    type: z.literal("direct"),
+    name: z.string(),
+    description: z.string(),
+    fn: z.function(),
+    schema: z.any(), // Accept any Zod schema
+});
 /** Tool schema - can be a string (built-in tool) or custom tool object. */
 const ToolSchema = z.union([
     z.string(),
     CustomToolSchema,
     FilesystemToolSchema,
+    DirectToolSchema,
 ]);
 /** Agent definition schema. */
 export const AgentDefinitionSchema = z.object({

package/dist/index.js

@@ -1,9 +1,15 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { makeHttpTransport, makeStdioTransport } from "./acp-server";
-// Load agent definition from shared JSON file at repo root
-const configPath = join(import.meta.dir, "../../agent.json");
-const exampleAgent = JSON.parse(readFileSync(configPath, "utf-8"));
+const exampleAgent = {
+    model: "claude-sonnet-4-5-20250929",
+    systemPrompt: "You are a helpful assistant.",
+    tools: [
+        "todo_write",
+        "get_weather",
+        "web_search",
+        { type: "filesystem", working_directory: "/Users/michael/code/town" },
+    ],
+    mcps: [],
+};
 // Parse transport type from command line argument
 const transport = process.argv[2] || "stdio";
 if (transport === "http") {

package/dist/runner/agent-runner.d.ts

@@ -9,6 +9,12 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"filesystem">;
         working_directory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"direct">;
+        name: z.ZodString;
+        description: z.ZodString;
+        fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        schema: z.ZodAny;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;

package/dist/runner/index.d.ts

@@ -1,6 +1,4 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "./agent-runner";
 export type { AgentRunner };
-export declare const makeRunnerFromDefinition: (
-	definition: AgentDefinition,
-) => AgentRunner;
+export declare const makeRunnerFromDefinition: (definition: AgentDefinition) => AgentRunner;

package/dist/runner/index.js

@@ -1,22 +1,18 @@
 import { zAgentRunnerParams } from "./agent-runner";
 import { LangchainAgent } from "./langchain";
 export const makeRunnerFromDefinition = (definition) => {
-	const agentRunnerParams = zAgentRunnerParams.safeParse(definition);
-	if (!agentRunnerParams.success) {
-		throw new Error(
-			`Invalid agent definition: ${agentRunnerParams.error.message}`,
-		);
-	}
-	switch (definition.harnessImplementation) {
-		case undefined:
-		case "langchain": {
-			return new LangchainAgent(agentRunnerParams.data);
-		}
-		default: {
-			const _exhaustiveCheck = definition.harnessImplementation;
-			throw new Error(
-				`Unsupported harness implementation: ${definition.harnessImplementation}`,
-			);
-		}
-	}
+    const agentRunnerParams = zAgentRunnerParams.safeParse(definition);
+    if (!agentRunnerParams.success) {
+        throw new Error(`Invalid agent definition: ${agentRunnerParams.error.message}`);
+    }
+    switch (definition.harnessImplementation) {
+        case undefined:
+        case "langchain": {
+            return new LangchainAgent(agentRunnerParams.data);
+        }
+        default: {
+            const _exhaustiveCheck = definition.harnessImplementation;
+            throw new Error(`Unsupported harness implementation: ${definition.harnessImplementation}`);
+        }
+    }
 };

package/dist/runner/langchain/index.js

@@ -73,6 +73,16 @@ export class LangchainAgent {
                         process.cwd();
                     enabledTools.push(...makeFilesystemTools(wd));
                 }
+                else if (type === "direct") {
+                    // Handle direct tool objects (imported in code)
+                    // biome-ignore lint/suspicious/noExplicitAny: mlai unsure how to best type this
+                    const addedTool = tool(t.fn, {
+                        name: t.name,
+                        description: t.description,
+                        schema: t.schema,
+                    });
+                    enabledTools.push(addedTool);
+                }
             }
         }
         // Built-in tools from registry

package/dist/runner/langchain/tools/todo.d.ts

@@ -1,49 +1,33 @@
 import { z } from "zod";
-export declare const todoItemSchema: z.ZodObject<
-	{
-		content: z.ZodString;
-		status: z.ZodEnum<{
-			pending: "pending";
-			in_progress: "in_progress";
-			completed: "completed";
-		}>;
-		activeForm: z.ZodString;
-	},
-	z.core.$strip
->;
-export declare const todoWrite: import("langchain").DynamicStructuredTool<
-	z.ZodObject<
-		{
-			todos: z.ZodArray<
-				z.ZodObject<
-					{
-						content: z.ZodString;
-						status: z.ZodEnum<{
-							pending: "pending";
-							in_progress: "in_progress";
-							completed: "completed";
-						}>;
-						activeForm: z.ZodString;
-					},
-					z.core.$strip
-				>
-			>;
-		},
-		z.core.$strip
-	>,
-	{
-		todos: {
-			content: string;
-			status: "pending" | "in_progress" | "completed";
-			activeForm: string;
-		}[];
-	},
-	{
-		todos: {
-			content: string;
-			status: "pending" | "in_progress" | "completed";
-			activeForm: string;
-		}[];
-	},
-	string
->;
+export declare const todoItemSchema: z.ZodObject<{
+    content: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+    }>;
+    activeForm: z.ZodString;
+}, z.core.$strip>;
+export declare const todoWrite: import("langchain").DynamicStructuredTool<z.ZodObject<{
+    todos: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+        }>;
+        activeForm: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, {
+    todos: {
+        content: string;
+        status: "pending" | "in_progress" | "completed";
+        activeForm: string;
+    }[];
+}, {
+    todos: {
+        content: string;
+        status: "pending" | "in_progress" | "completed";
+        activeForm: string;
+    }[];
+}, string>;

package/dist/runner/langchain/tools/todo.js

@@ -1,18 +1,16 @@
 import { tool } from "langchain";
 import { z } from "zod";
 export const todoItemSchema = z.object({
-	content: z.string().min(1),
-	status: z.enum(["pending", "in_progress", "completed"]),
-	activeForm: z.string().min(1),
+    content: z.string().min(1),
+    status: z.enum(["pending", "in_progress", "completed"]),
+    activeForm: z.string().min(1),
 });
-export const todoWrite = tool(
-	({ todos }) => {
-		// Simple implementation that confirms the todos were written
-		return `Successfully updated todo list with ${todos.length} items`;
-	},
-	{
-		name: "todo_write",
-		description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+export const todoWrite = tool(({ todos }) => {
+    // Simple implementation that confirms the todos were written
+    return `Successfully updated todo list with ${todos.length} items`;
+}, {
+    name: "todo_write",
+    description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
 
 ## When to Use This Tool
@@ -73,8 +71,7 @@ NOTE that you should not use this tool if there is only one trivial task to do.
      - activeForm: "Fixing authentication bug"
 
 When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`,
-		schema: z.object({
-			todos: z.array(todoItemSchema),
-		}),
-	},
-);
+    schema: z.object({
+        todos: z.array(todoItemSchema),
+    }),
+});

package/dist/runner/langchain/tools/web_search.d.ts

@@ -1,4 +1,4 @@
 import { ExaSearchResults } from "@langchain/exa";
 export declare function makeWebSearchTool(): ExaSearchResults<{
-	text: true;
+    text: true;
 }>;

package/dist/runner/langchain/tools/web_search.js

@@ -1,26 +1,23 @@
 import { ExaSearchResults } from "@langchain/exa";
 import Exa from "exa-js";
-
 let _webSearchInstance = null;
 export function makeWebSearchTool() {
-	if (_webSearchInstance) {
-		return _webSearchInstance;
-	}
-	const apiKey = process.env.EXA_API_KEY;
-	if (!apiKey) {
-		throw new Error(
-			"EXA_API_KEY environment variable is required to use the web_search tool. " +
-				"Please set it to your Exa API key from https://exa.ai",
-		);
-	}
-	const client = new Exa(apiKey);
-	_webSearchInstance = new ExaSearchResults({
-		client,
-		searchArgs: {
-			numResults: 5,
-			type: "auto",
-			text: true,
-		},
-	});
-	return _webSearchInstance;
+    if (_webSearchInstance) {
+        return _webSearchInstance;
+    }
+    const apiKey = process.env.EXA_API_KEY;
+    if (!apiKey) {
+        throw new Error("EXA_API_KEY environment variable is required to use the web_search tool. " +
+            "Please set it to your Exa API key from https://exa.ai");
+    }
+    const client = new Exa(apiKey);
+    _webSearchInstance = new ExaSearchResults({
+        client,
+        searchArgs: {
+            numResults: 5,
+            type: "auto",
+            text: true,
+        },
+    });
+    return _webSearchInstance;
 }

package/dist/runner/tools.d.ts

@@ -1,6 +1,14 @@
 import { z } from "zod";
 /** Built-in tool types. */
 export declare const zBuiltInToolType: z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">]>;
+/** Direct tool object schema (for tools imported directly in code). */
+declare const zDirectTool: z.ZodObject<{
+    type: z.ZodLiteral<"direct">;
+    name: z.ZodString;
+    description: z.ZodString;
+    fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    schema: z.ZodAny;
+}, z.core.$strip>;
 /** Tool type - can be a built-in tool string or custom tool object. */
 export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">]>, z.ZodObject<{
     type: z.ZodLiteral<"custom">;
@@ -8,6 +16,14 @@ export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodL
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"filesystem">;
     working_directory: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"direct">;
+    name: z.ZodString;
+    description: z.ZodString;
+    fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    schema: z.ZodAny;
 }, z.core.$strip>]>;
 export type ToolType = z.infer<typeof zToolType>;
 export type BuiltInToolType = z.infer<typeof zBuiltInToolType>;
+export type DirectTool = z.infer<typeof zDirectTool>;
+export {};

package/dist/runner/tools.js

@@ -6,7 +6,7 @@ export const zBuiltInToolType = z.union([
     z.literal("web_search"),
     z.literal("filesystem"),
 ]);
-/** Custom tool schema. */
+/** Custom tool schema (loaded from module path). */
 const zCustomTool = z.object({
     type: z.literal("custom"),
     modulePath: z.string(),
@@ -16,9 +16,18 @@ const zFilesystemTool = z.object({
     type: z.literal("filesystem"),
     working_directory: z.string().optional(),
 });
+/** Direct tool object schema (for tools imported directly in code). */
+const zDirectTool = z.object({
+    type: z.literal("direct"),
+    name: z.string(),
+    description: z.string(),
+    fn: z.function(),
+    schema: z.any(), // Accept any Zod schema
+});
 /** Tool type - can be a built-in tool string or custom tool object. */
 export const zToolType = z.union([
     zBuiltInToolType,
     zCustomTool,
     zFilesystemTool,
+    zDirectTool,
 ]);

package/dist/scaffold/copy-gui.js

@@ -1,4 +1,4 @@
-import { cp, mkdir, writeFile } from "node:fs/promises";
+import { cp, mkdir, readFile, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 const require = createRequire(import.meta.url);
@@ -34,84 +34,10 @@ export async function copyGuiApp(agentPath) {
         const targetPath = join(guiDir, item);
         await cp(sourcePath, targetPath, { recursive: true });
     }
-    // Create a standalone tsconfig.json for the GUI (can't extend from workspace tsconfig)
-    const guiTsConfig = {
-        compilerOptions: {
-            allowArbitraryExtensions: true,
-            allowUnreachableCode: false,
-            allowUnusedLabels: false,
-            declaration: true,
-            emitDecoratorMetadata: true,
-            esModuleInterop: true,
-            exactOptionalPropertyTypes: true,
-            experimentalDecorators: true,
-            jsx: "react-jsx",
-            lib: ["DOM", "ESNext"],
-            module: "ESNext",
-            moduleResolution: "bundler",
-            noFallthroughCasesInSwitch: true,
-            noImplicitAny: true,
-            noImplicitOverride: true,
-            noImplicitReturns: true,
-            noUncheckedIndexedAccess: true,
-            noUncheckedSideEffectImports: true,
-            noUnusedLocals: false,
-            noUnusedParameters: true,
-            resolveJsonModule: true,
-            skipLibCheck: true,
-            strict: true,
-            stripInternal: true,
-            target: "ESNext",
-            verbatimModuleSyntax: true,
-            outDir: "./dist",
-            rootDir: "./src",
-        },
-        include: ["src/**/*"],
-        exclude: ["node_modules", "dist"],
-    };
-    await writeFile(join(guiDir, "tsconfig.json"), JSON.stringify(guiTsConfig, null, 2));
-    // Generate a custom package.json for the GUI
-    // Use @townco/ui as a dependency instead of copying files
-    const packageJson = {
-        name: "agent-gui",
-        version: "0.0.1",
-        type: "module",
-        private: true,
-        scripts: {
-            dev: "vite",
-            build: "vite build",
-            preview: "vite preview",
-        },
-        dependencies: {
-            "@townco/ui": "^0.1.0",
-            "@agentclientprotocol/sdk": "^0.5.1",
-            "@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",
-            "class-variance-authority": "^0.7.1",
-            clsx: "^2.1.1",
-            "lucide-react": "^0.552.0",
-            react: "^19.2.0",
-            "react-dom": "^19.2.0",
-            "react-markdown": "^10.1.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",
-        },
-    };
-    await writeFile(join(guiDir, "package.json"), JSON.stringify(packageJson, null, 2));
+    // Fix the @source path in index.css to point to the correct node_modules location
+    // In agent projects, node_modules is at the project root (4 levels up from gui/src/)
+    const indexCssPath = join(guiDir, "src", "index.css");
+    const indexCssContent = await readFile(indexCssPath, "utf-8");
+    const updatedContent = indexCssContent.replace('@source "../node_modules/@townco/ui/dist/**/*.{js,d.ts}";', '@source "../../../../node_modules/@townco/ui/dist/**/*.{js,d.ts}";');
+    await writeFile(indexCssPath, updatedContent, "utf-8");
 }

package/dist/scaffold/copy-tui.js

@@ -1,4 +1,4 @@
-import { cp, mkdir, writeFile } from "node:fs/promises";
+import { cp, mkdir } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 const require = createRequire(import.meta.url);
@@ -29,68 +29,4 @@ export async function copyTuiApp(agentPath) {
         const targetPath = join(tuiDir, item);
         await cp(sourcePath, targetPath, { recursive: true });
     }
-    // Create a standalone tsconfig.json for the TUI
-    const tuiTsConfig = {
-        compilerOptions: {
-            allowArbitraryExtensions: true,
-            allowUnreachableCode: false,
-            allowUnusedLabels: false,
-            declaration: true,
-            emitDecoratorMetadata: true,
-            esModuleInterop: true,
-            exactOptionalPropertyTypes: true,
-            experimentalDecorators: true,
-            jsx: "react-jsx",
-            lib: ["ESNext"],
-            module: "ESNext",
-            moduleResolution: "bundler",
-            noFallthroughCasesInSwitch: true,
-            noImplicitAny: true,
-            noImplicitOverride: true,
-            noImplicitReturns: true,
-            noUncheckedIndexedAccess: true,
-            noUncheckedSideEffectImports: true,
-            noUnusedLocals: false,
-            noUnusedParameters: true,
-            resolveJsonModule: true,
-            skipLibCheck: true,
-            strict: true,
-            stripInternal: true,
-            target: "ESNext",
-            verbatimModuleSyntax: true,
-            outDir: "./dist",
-            rootDir: "./src",
-        },
-        include: ["src/**/*"],
-        exclude: ["node_modules", "dist"],
-    };
-    await writeFile(join(tuiDir, "tsconfig.json"), JSON.stringify(tuiTsConfig, null, 2));
-    // Generate a custom package.json for the TUI
-    const packageJson = {
-        name: "agent-tui",
-        version: "0.0.1",
-        type: "module",
-        private: true,
-        bin: {
-            "agent-tui": "./dist/index.js",
-        },
-        scripts: {
-            build: "tsc",
-            start: "bun dist/index.js",
-        },
-        dependencies: {
-            "@townco/ui": "^0.1.0",
-            "@optique/core": "^0.6.2",
-            "@optique/run": "^0.6.2",
-            ink: "^6.4.0",
-            "ink-text-input": "^6.0.0",
-            react: "^19.2.0",
-        },
-        devDependencies: {
-            "@types/node": "^24.10.0",
-            "@types/react": "^19.2.2",
-            typescript: "^5.9.3",
-        },
-    };
-    await writeFile(join(tuiDir, "package.json"), JSON.stringify(packageJson, null, 2));
 }

package/dist/scaffold/index.d.ts

@@ -5,6 +5,7 @@ export interface ScaffoldOptions {
     overwrite?: boolean;
     includeGui?: boolean;
     includeTui?: boolean;
+    agentsDir: string;
 }
 export interface ScaffoldResult {
     success: boolean;
@@ -15,3 +16,4 @@ export interface ScaffoldResult {
  * Scaffold a new agent package
  */
 export declare function scaffoldAgent(options: ScaffoldOptions): Promise<ScaffoldResult>;
+export { scaffoldProject } from "./project-scaffold";