@agentuity/cli 0.0.101 → 0.0.102

package/dist/cmd/ai/prompt/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/agent.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,yCAU1B,CAAC;AAEH,wBAAgB,iBAAiB,IAAI,MAAM,CAoU1C"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/agent.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe,yCAU1B,CAAC;AAEH;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/cmd/ai/prompt/agent.js

@@ -1,5 +1,7 @@
 import { createSubcommand } from '../../../types';
 import { getCommand } from '../../../command-prefix';
+import { appendHashComment } from './version';
+import agentPromptContent from './agent.md' with { type: 'text' };
 export const agentSubcommand = createSubcommand({
     name: 'agent',
     description: 'Generate a comprehensive prompt for LLM agents for the agents folder',
@@ -11,329 +13,16 @@ export const agentSubcommand = createSubcommand({
         console.log(prompt);
     },
 });
-export function generateLLMPrompt() {
-    return `# Agents Folder Guide
-
-This folder contains AI agents for your Agentuity application. Each agent is organized in its own subdirectory.
-
-## Directory Structure
-
-Each agent folder must contain:
-- **agent.ts** (required) - Agent definition with metadata, schema, and handler
-- **route.ts** (optional) - HTTP routes for the agent endpoint
-
-Example structure:
-\`\`\`
-src/agent/
-├── hello/
-│   ├── agent.ts
-│   └── route.ts
-├── process-data/
-│   ├── agent.ts
-│   └── route.ts
-└── registry.generated.ts (auto-generated)
-\`\`\`
-
-## Creating an Agent
-
-### Basic Agent (agent.ts)
-
-\`\`\`typescript
-import { createAgent } from '@agentuity/runtime';
-import { s } from '@agentuity/schema';
-
-const agent = createAgent({
-	metadata: {
-		name: 'My Agent',
-		description: 'What this agent does',
-	},
-	schema: {
-		input: s.object({ 
-			name: s.string(),
-			age: s.number() 
-		}),
-		output: s.string(),
-	},
-	handler: async (c, input) => {
-		// Access context: c.app, c.config, c.logger, c.kv, c.vector, c.stream
-		return \`Hello, \${input.name}! You are \${input.age} years old.\`;
-	},
-});
-
-export default agent;
-\`\`\`
-
-### Agent with Lifecycle (setup/shutdown)
-
-\`\`\`typescript
-import { createAgent, type AppState } from '@agentuity/runtime';
-import { s } from '@agentuity/schema';
-
-const agent = createAgent({
-	metadata: {
-		name: 'Lifecycle Agent',
-		description: 'Agent with setup and shutdown',
-	},
-	schema: {
-		input: s.object({ message: s.string() }),
-		output: s.object({ result: s.string() }),
-	},
-	setup: async (app: AppState) => {
-		// Initialize resources (runs once on startup)
-		console.log('Setting up agent for app:', app.appName);
-		return {
-			agentId: \`agent-\${Math.random().toString(36).substr(2, 9)}\`,
-			connectionPool: ['conn-1', 'conn-2'],
-		};
-	},
-	handler: async (ctx, input) => {
-		// Access setup config via ctx.config (fully typed)
-		console.log('Agent ID:', ctx.config.agentId);
-		console.log('Connections:', ctx.config.connectionPool);
-		return { result: \`Processed: \${input.message}\` };
-	},
-	shutdown: async (app, config) => {
-		// Cleanup resources (runs on shutdown)
-		console.log('Shutting down agent:', config.agentId);
-	},
-});
-
-export default agent;
-\`\`\`
-
-### Agent with Event Listeners
-
-\`\`\`typescript
-const agent = createAgent({
-	// ... configuration
-});
-
-agent.addEventListener('started', (eventName, agent, ctx) => {
-	console.log('Agent started:', ctx.config.agentId);
-});
-
-agent.addEventListener('completed', (eventName, agent, ctx) => {
-	console.log('Agent completed');
-});
-
-export default agent;
-\`\`\`
-
-## Creating Routes (route.ts)
-
-Routes expose HTTP endpoints for your agent:
-
-\`\`\`typescript
-import { createRouter } from '@agentuity/runtime';
-import agent from './agent';
-
-const router = createRouter();
-
-// GET /agent/hello
-router.get('/', async (c) => {
-	const result = await c.agent.hello.run({ name: 'World', age: 25 });
-	return c.text(result);
-});
-
-// POST /agent/hello with validation
-router.post('/', agent.validator(), async (c) => {
-	const data = c.req.valid('json');
-	const result = await c.agent.hello.run(data);
-	return c.text(result);
-});
-
-export default router;
-\`\`\`
-
-## Agent Context (c)
-
-The handler receives a context object with:
-
-- **c.app** - Application state (appName, version, startedAt, config)
-- **c.config** - Agent-specific config (from setup return value, fully typed)
-- **c.logger** - Structured logger (info, warn, error, debug, trace)
-- **c.kv** - Key-value storage
-- **c.vector** - Vector storage
-- **c.stream** - Stream management (create, list, delete)
-- **c.agent** - Access to other agents (c.agent.otherAgent.run())
-
-## Context in Routes (c)
-
-Route handlers have additional context:
-
-- **c.req** - Hono request object
-- **c.var.logger** - Logger instance
-- **Import agents directly** - Import and call agents directly instead of using c.var.agent
-
-## Examples
-
-### Using Key-Value Storage
-
-\`\`\`typescript
-handler: async (c, input) => {
-	await c.kv.set('user:123', { name: 'Alice', age: 30 });
-	const user = await c.kv.get('user:123');
-	return user;
-}
-\`\`\`
-
-### Using Streams
-
-\`\`\`typescript
-handler: async (c, input) => {
-	const stream = await c.stream.create('output', {
-		metadata: { createdBy: 'my-agent' },
-		contentType: 'text/plain',
-	});
-	await stream.write('Hello from stream');
-	await stream.close();
-	return { streamId: stream.id, url: stream.url };
+/**
+ * Get the raw prompt content without hash.
+ */
+export function getPromptContent() {
+    return agentPromptContent;
 }
-\`\`\`
-
-### Calling Another Agent
-
-\`\`\`typescript
-handler: async (c, input) => {
-	const result = await c.agent.otherAgent.run({ data: input.value });
-	return \`Other agent returned: \${result}\`;
-}
-\`\`\`
-
-## Subagents (Nested Agents)
-
-Agents can have subagents organized one level deep. This is useful for grouping related functionality.
-
-### Directory Structure for Subagents
-
-\`\`\`
-src/agent/
-└── team/              # Parent agent
-    ├── agent.ts       # Parent agent
-    ├── route.ts       # Parent routes
-    ├── members/       # Subagent
-    │   ├── agent.ts
-    │   └── route.ts
-    └── tasks/         # Subagent
-        ├── agent.ts
-        └── route.ts
-\`\`\`
-
-### Parent Agent
-
-\`\`\`typescript
-import { createAgent } from '@agentuity/runtime';
-import { s } from '@agentuity/schema';
-
-const agent = createAgent({
-	metadata: {
-		name: 'Team Manager',
-	},
-	schema: {
-		input: s.object({ action: s.union([s.literal('info'), s.literal('count')]) }),
-		output: s.object({ 
-			message: s.string(),
-			timestamp: s.string() 
-		}),
-	},
-	handler: async (ctx, { action }) => {
-		return {
-			message: 'Team parent agent - manages members and tasks',
-			timestamp: new Date().toISOString(),
-		};
-	},
-});
-
-export default agent;
-\`\`\`
-
-### Subagent (Accessing Parent)
-
-\`\`\`typescript
-import { createAgent } from '@agentuity/runtime';
-import { s } from '@agentuity/schema';
-
-const agent = createAgent({
-	metadata: {
-		name: 'Members Subagent',
-	},
-	schema: {
-		input: s.object({
-			action: s.union([s.literal('list'), s.literal('add'), s.literal('remove')]),
-			name: s.optional(s.string()),
-		}),
-		output: s.object({
-			members: s.array(s.string()),
-			parentInfo: s.optional(s.string()),
-		}),
-	},
-	handler: async (ctx, { action, name }) => {
-		// Access parent agent
-		const parentResult = await ctx.agent.team.run({ action: 'info' });
-		const parentInfo = \`Parent says: \${parentResult.message}\`;
-		
-		// Subagent logic here
-		let members = ['Alice', 'Bob'];
-		if (action === 'add' && name) {
-			members.push(name);
-		}
-		
-		return { members, parentInfo };
-	},
-});
-
-export default agent;
-\`\`\`
-
-### Accessing Subagents from Routes
-
-\`\`\`typescript
-import { createRouter } from '@agentuity/runtime';
-
-const router = createRouter();
-
-router.get('/', async (c) => {
-	// Call parent agent
-	const teamInfo = await c.agent.team.run({ action: 'info' });
-	
-	// Call subagents (nested access)
-	const members = await c.agent.team.members.run({ action: 'list' });
-	const tasks = await c.agent.team.tasks.run({ action: 'list' });
-	
-	return c.json({ teamInfo, members, tasks });
-});
-
-export default router;
-\`\`\`
-
-### Subagent Routes
-
-Routes for subagents automatically mount under the parent path:
-
-- Parent: \`/agent/team\`
-- Subagent: \`/agent/team/members\`
-- Subagent: \`/agent/team/tasks\`
-
-### Key Points About Subagents
-
-- **One level deep**: Only one level of nesting is supported (no nested subagents)
-- **Access parent**: Subagents can call their parent via \`ctx.agent.parentName.run()\`
-- **Agent names**: Subagents have dotted names like \`"team.members"\`
-- **Route hierarchy**: Routes inherit parent path structure
-- **Shared context**: Subagents share the same app context (kv, logger, etc.)
-
-## Rules
-
-- Each agent folder name becomes the agent's route name (e.g., \`hello/\` → \`/agent/hello\`)
-- **agent.ts** must export default the agent instance
-- **route.ts** must export default the router instance
-- Input/output schemas are enforced with @agentuity/schema validation
-- Setup return value type automatically flows to ctx.config (fully typed)
-- Use c.logger for logging, not console.log
-- Agent names in routes are accessed via c.agent.{folderName}
-- Subagents are one level deep only (team/members/, not team/members/subagent/)
-- Subagent routes mount under parent path (/agent/team/members)
-- Agents do not necessary need a route.ts file if they aren't exposed externally
-`;
+/**
+ * Generate the agent prompt with hash comment.
+ */
+export function generateLLMPrompt() {
+    return appendHashComment(agentPromptContent);
 }
 //# sourceMappingURL=agent.js.map

package/dist/cmd/ai/prompt/agent.js.map

@@ -1 +1 @@
-{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,MAAM,CAAC,MAAM,eAAe,GAAG,gBAAgB,CAAC;IAC/C,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,sEAAsE;IACnF,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACrF,KAAK,CAAC,OAAO,CAAC,IAAoB;QACjC,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;QACnC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,CAAC;CACD,CAAC,CAAC;AAEH,MAAM,UAAU,iBAAiB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkUP,CAAC;AACF,CAAC"}
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,kBAAkB,MAAM,YAAY,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAElE,MAAM,CAAC,MAAM,eAAe,GAAG,gBAAgB,CAAC;IAC/C,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,sEAAsE;IACnF,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACrF,KAAK,CAAC,OAAO,CAAC,IAAoB;QACjC,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;QACnC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,CAAC;CACD,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC/B,OAAO,kBAAkB,CAAC;AAC3B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB;IAChC,OAAO,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;AAC9C,CAAC"}

package/dist/cmd/ai/prompt/api.d.ts

@@ -1,3 +1,10 @@
 export declare const apiSubcommand: import("../../..").SubcommandDefinition;
+/**
+ * Get the raw prompt content without hash.
+ */
+export declare function getPromptContent(): string;
+/**
+ * Generate the API prompt with hash comment.
+ */
 export declare function generateLLMPrompt(): string;
 //# sourceMappingURL=api.d.ts.map

package/dist/cmd/ai/prompt/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/api.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa,yCAUxB,CAAC;AAEH,wBAAgB,iBAAiB,IAAI,MAAM,CAqQ1C"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/api.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa,yCAUxB,CAAC;AAEH;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/cmd/ai/prompt/api.js

@@ -1,5 +1,7 @@
 import { createSubcommand } from '../../../types';
 import { getCommand } from '../../../command-prefix';
+import { appendHashComment } from './version';
+import apiPromptContent from './api.md' with { type: 'text' };
 export const apiSubcommand = createSubcommand({
     name: 'api',
     description: 'Generate a comprehensive prompt for LLM agents for the apis folder',
@@ -11,266 +13,16 @@ export const apiSubcommand = createSubcommand({
         console.log(prompt);
     },
 });
+/**
+ * Get the raw prompt content without hash.
+ */
+export function getPromptContent() {
+    return apiPromptContent;
+}
+/**
+ * Generate the API prompt with hash comment.
+ */
 export function generateLLMPrompt() {
-    return `# APIs Folder Guide
-
-This folder contains REST API routes for your Agentuity application. Each API is organized in its own subdirectory.
-
-## Directory Structure
-
-Each API folder must contain:
-- **route.ts** (required) - HTTP route definitions using Hono router
-
-Example structure:
-\`\`\`
-src/api/
-├── index.ts         (optional, mounted at /api)
-├── status/
-│   └── route.ts     (mounted at /api/status)
-├── users/
-│   └── route.ts     (mounted at /api/users)
-├── agent-call/
-    └── route.ts     (mounted at /api/agent-call)
-\`\`\`
-
-## Creating an API
-
-### Basic API (route.ts)
-
-\`\`\`typescript
-import { createRouter } from '@agentuity/runtime';
-
-const router = createRouter();
-
-// GET /api/status
-router.get('/', (c) => {
-	return c.json({
-		status: 'ok',
-		timestamp: new Date().toISOString(),
-		version: '1.0.0',
-	});
-});
-
-// POST /api/status
-router.post('/', async (c) => {
-	const body = await c.req.json();
-	return c.json({ received: body });
-});
-
-export default router;
-\`\`\`
-
-### API with Request Validation
-
-\`\`\`typescript
-import { createRouter } from '@agentuity/runtime';
-import { s } from '@agentuity/schema';
-
-const router = createRouter();
-
-const createUserSchema = s.object({
-	name: s.string(),
-	email: s.string(),
-	age: s.number(),
-});
-
-const validator = createRouter.validator({
-	input: createUserSchema,
-});
-
-router.post('/', validator, async (c) => {
-	const data = c.req.valid('json');
-	// data is fully typed: { name: string, email: string, age: number }
-	return c.json({ 
-		success: true, 
-		user: data 
-	});
-});
-
-export default router;
-\`\`\`
-
-### API Calling Agents
-
-APIs can call agents directly:
-
-\`\`\`typescript
-import { createRouter } from '@agentuity/runtime';
-
-const router = createRouter();
-
-router.get('/', async (c) => {
-	// Call an agent from the agents/ folder
-	const result = await c.agent.hello.run({ name: 'API Caller', age: 42 });
-	
-	return c.json({
-		success: true,
-		agentResult: result,
-	});
-});
-
-router.post('/with-input', async (c) => {
-	const body = await c.req.json();
-	const { name, age } = body;
-	
-	// Call agent with dynamic input
-	const result = await c.agent.simple.run({ name, age });
-	
-	return c.json({
-		success: true,
-		agentResult: result,
-	});
-});
-
-export default router;
-\`\`\`
-
-### API with Logging
-
-\`\`\`typescript
-import { createRouter } from '@agentuity/runtime';
-
-const router = createRouter();
-
-router.get('/log-test', (c) => {
-	c.var.logger.info('Info message');
-	c.var.logger.error('Error message');
-	c.var.logger.warn('Warning message');
-	c.var.logger.debug('Debug message');
-	c.var.logger.trace('Trace message');
-	
-	return c.text('Check logs');
-});
-
-export default router;
-\`\`\`
-
-## Route Context (c)
-
-The route handler receives a Hono context object with:
-
-- **c.req** - Request object (c.req.json(), c.req.param(), c.req.query(), etc.)
-- **c.json()** - Return JSON response
-- **c.text()** - Return text response
-- **c.html()** - Return HTML response
-- **c.redirect()** - Redirect to URL
-- **c.var.logger** - Structured logger (info, warn, error, debug, trace)
-- **Import agents directly** - Import and call agents directly instead of using c.var.agent
-- **c.var.kv** - Key-value storage
-- **c.var.vector** - Vector storage
-- **c.var.stream** - Stream management
-
-## HTTP Methods
-
-\`\`\`typescript
-const router = createRouter();
-
-router.get('/path', (c) => { /* ... */ });
-router.post('/path', (c) => { /* ... */ });
-router.put('/path', (c) => { /* ... */ });
-router.patch('/path', (c) => { /* ... */ });
-router.delete('/path', (c) => { /* ... */ });
-router.options('/path', (c) => { /* ... */ });
-\`\`\`
-
-## Path Parameters
-
-\`\`\`typescript
-// GET /api/users/:id
-router.get('/:id', (c) => {
-	const id = c.req.param('id');
-	return c.json({ userId: id });
-});
-
-// GET /api/posts/:postId/comments/:commentId
-router.get('/:postId/comments/:commentId', (c) => {
-	const postId = c.req.param('postId');
-	const commentId = c.req.param('commentId');
-	return c.json({ postId, commentId });
-});
-\`\`\`
-
-## Query Parameters
-
-\`\`\`typescript
-// GET /api/search?q=hello&limit=10
-router.get('/search', (c) => {
-	const query = c.req.query('q');
-	const limit = c.req.query('limit') || '20';
-	return c.json({ query, limit: parseInt(limit) });
-});
-\`\`\`
-
-## Request Body
-
-\`\`\`typescript
-// JSON body
-router.post('/', async (c) => {
-	const body = await c.req.json();
-	return c.json({ received: body });
-});
-
-// Form data
-router.post('/upload', async (c) => {
-	const formData = await c.req.formData();
-	const file = formData.get('file');
-	return c.json({ fileName: file?.name });
-});
-\`\`\`
-
-## Error Handling
-
-\`\`\`typescript
-router.get('/', async (c) => {
-	try {
-		const result = await c.agent.myAgent.run({ data: 'test' });
-		return c.json({ success: true, result });
-	} catch (error) {
-		c.var.logger.error('Agent call failed:', error);
-		return c.json(
-			{
-				success: false,
-				error: error instanceof Error ? error.message : String(error),
-			},
-			500
-		);
-	}
-});
-\`\`\`
-
-## Response Types
-
-\`\`\`typescript
-// JSON response
-return c.json({ data: 'value' });
-
-// Text response
-return c.text('Hello World');
-
-// HTML response
-return c.html('<h1>Hello</h1>');
-
-// Custom status code
-return c.json({ error: 'Not found' }, 404);
-
-// Redirect
-return c.redirect('/new-path');
-
-// Headers
-return c.json({ data: 'value' }, 200, {
-	'X-Custom-Header': 'value',
-});
-\`\`\`
-
-## Rules
-
-- Each API folder name becomes the route name (e.g., \`status/\` → \`/api/status\`)
-- **route.ts** must export default the router instance
-- Use c.var.logger for logging, not console.log
-- All agents are accessible via c.agent.{agentName}
-- Validation should use @agentuity/schema or any Standard Schema compatible library
-- Return appropriate HTTP status codes
-- APIs run at \`/api/{folderName}\` by default
-`;
+    return appendHashComment(apiPromptContent);
 }
 //# sourceMappingURL=api.js.map

package/dist/cmd/ai/prompt/api.js.map

@@ -1 +1 @@
-{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,MAAM,CAAC,MAAM,aAAa,GAAG,gBAAgB,CAAC;IAC7C,IAAI,EAAE,KAAK;IACX,WAAW,EAAE,oEAAoE;IACjF,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,YAAY,CAAC,EAAE,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjF,KAAK,CAAC,OAAO,CAAC,IAAoB;QACjC,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;QACnC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,CAAC;CACD,CAAC,CAAC;AAEH,MAAM,UAAU,iBAAiB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmQP,CAAC;AACF,CAAC"}
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,gBAAgB,MAAM,UAAU,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAE9D,MAAM,CAAC,MAAM,aAAa,GAAG,gBAAgB,CAAC;IAC7C,IAAI,EAAE,KAAK;IACX,WAAW,EAAE,oEAAoE;IACjF,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,YAAY,CAAC,EAAE,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjF,KAAK,CAAC,OAAO,CAAC,IAAoB;QACjC,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;QACnC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,CAAC;CACD,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC/B,OAAO,gBAAgB,CAAC;AACzB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB;IAChC,OAAO,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;AAC5C,CAAC"}

package/dist/cmd/ai/prompt/version.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Prompt file versioning utilities.
+ *
+ * Hash format at end of file: <!-- prompt_hash: [hash] -->
+ *
+ * - hash: SHA256 of file content (excluding the hash line)
+ *
+ * This allows detecting if the source template has changed.
+ */
+/**
+ * Compute SHA256 hash of content using Bun's built-in hasher.
+ */
+export declare function computeHash(content: string): string;
+/**
+ * Strip the hash comment from content.
+ */
+export declare function stripHashComment(content: string): string;
+/**
+ * Extract hash from file content.
+ * Returns null if no hash comment found.
+ */
+export declare function extractHash(content: string): string | null;
+/**
+ * Generate content with hash comment appended.
+ */
+export declare function appendHashComment(content: string): string;
+/**
+ * Check if a file needs to be updated based on hash comparison.
+ *
+ * @param fileContent - Current file content (with hash comment)
+ * @param sourceContent - Source template content (without hash comment)
+ * @returns true if file needs to be updated (hashes differ)
+ */
+export declare function needsUpdate(fileContent: string, sourceContent: string): boolean;
+//# sourceMappingURL=version.d.ts.map

package/dist/cmd/ai/prompt/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../src/cmd/ai/prompt/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAInD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG1D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAQ/E"}