@renseiai/agentfactory 0.8.0

package/dist/src/templates/adapters.test.js

@@ -0,0 +1,165 @@
+import { describe, it, expect } from 'vitest';
+import { ClaudeToolPermissionAdapter, CodexToolPermissionAdapter, SpringAiToolPermissionAdapter, createToolPermissionAdapter, } from './adapters.js';
+describe('ClaudeToolPermissionAdapter', () => {
+    const adapter = new ClaudeToolPermissionAdapter();
+    it('translates shell command with glob', () => {
+        const result = adapter.translatePermissions([{ shell: 'pnpm *' }]);
+        expect(result).toEqual(['Bash(pnpm:*)']);
+    });
+    it('translates multi-word shell command', () => {
+        const result = adapter.translatePermissions([{ shell: 'git commit *' }]);
+        expect(result).toEqual(['Bash(git commit:*)']);
+    });
+    it('translates git push command', () => {
+        const result = adapter.translatePermissions([{ shell: 'git push *' }]);
+        expect(result).toEqual(['Bash(git push:*)']);
+    });
+    it('translates user-input to AskUserQuestion', () => {
+        const result = adapter.translatePermissions(['user-input']);
+        expect(result).toEqual(['AskUserQuestion']);
+    });
+    it('passes through other string permissions', () => {
+        const result = adapter.translatePermissions(['Read', 'Write']);
+        expect(result).toEqual(['Read', 'Write']);
+    });
+    it('translates single-word shell command', () => {
+        const result = adapter.translatePermissions([{ shell: 'ls' }]);
+        expect(result).toEqual(['Bash(ls:*)']);
+    });
+    it('handles mixed permissions', () => {
+        const result = adapter.translatePermissions([
+            { shell: 'pnpm *' },
+            'user-input',
+            { shell: 'gh pr *' },
+        ]);
+        expect(result).toEqual([
+            'Bash(pnpm:*)',
+            'AskUserQuestion',
+            'Bash(gh pr:*)',
+        ]);
+    });
+});
+describe('CodexToolPermissionAdapter', () => {
+    const adapter = new CodexToolPermissionAdapter();
+    it('translates shell command to shell: prefix format', () => {
+        const result = adapter.translatePermissions([{ shell: 'pnpm *' }]);
+        expect(result).toEqual(['shell:pnpm *']);
+    });
+    it('translates multi-word shell command', () => {
+        const result = adapter.translatePermissions([{ shell: 'git commit *' }]);
+        expect(result).toEqual(['shell:git commit *']);
+    });
+    it('passes through user-input as-is (Codex exec is non-interactive)', () => {
+        const result = adapter.translatePermissions(['user-input']);
+        expect(result).toEqual(['user-input']);
+    });
+    it('passes through other string permissions as-is', () => {
+        const result = adapter.translatePermissions(['Read', 'Write']);
+        expect(result).toEqual(['Read', 'Write']);
+    });
+    it('translates single-word shell command', () => {
+        const result = adapter.translatePermissions([{ shell: 'ls' }]);
+        expect(result).toEqual(['shell:ls']);
+    });
+    it('handles mixed permissions', () => {
+        const result = adapter.translatePermissions([
+            { shell: 'pnpm *' },
+            'user-input',
+            { shell: 'gh pr *' },
+        ]);
+        expect(result).toEqual([
+            'shell:pnpm *',
+            'user-input',
+            'shell:gh pr *',
+        ]);
+    });
+    it('handles empty permissions array', () => {
+        const result = adapter.translatePermissions([]);
+        expect(result).toEqual([]);
+    });
+});
+describe('SpringAiToolPermissionAdapter', () => {
+    const adapter = new SpringAiToolPermissionAdapter();
+    it('translates shell command to spring-tool format', () => {
+        const result = adapter.translatePermissions([{ shell: 'pnpm *' }]);
+        expect(result).toEqual(['spring-tool:shell:pnpm *']);
+    });
+    it('translates multi-word shell command', () => {
+        const result = adapter.translatePermissions([{ shell: 'git commit *' }]);
+        expect(result).toEqual(['spring-tool:shell:git commit *']);
+    });
+    it('passes through user-input as-is (Spring AI agent is non-interactive)', () => {
+        const result = adapter.translatePermissions(['user-input']);
+        expect(result).toEqual(['user-input']);
+    });
+    it('passes through other string permissions as-is', () => {
+        const result = adapter.translatePermissions(['Read', 'Write']);
+        expect(result).toEqual(['Read', 'Write']);
+    });
+    it('translates single-word shell command', () => {
+        const result = adapter.translatePermissions([{ shell: 'ls' }]);
+        expect(result).toEqual(['spring-tool:shell:ls']);
+    });
+    it('handles mixed permissions', () => {
+        const result = adapter.translatePermissions([
+            { shell: 'pnpm *' },
+            'user-input',
+            { shell: 'gh pr *' },
+        ]);
+        expect(result).toEqual([
+            'spring-tool:shell:pnpm *',
+            'user-input',
+            'spring-tool:shell:gh pr *',
+        ]);
+    });
+    it('handles empty permissions array', () => {
+        const result = adapter.translatePermissions([]);
+        expect(result).toEqual([]);
+    });
+});
+describe('createToolPermissionAdapter', () => {
+    it('returns ClaudeToolPermissionAdapter for claude', () => {
+        const adapter = createToolPermissionAdapter('claude');
+        expect(adapter).toBeInstanceOf(ClaudeToolPermissionAdapter);
+    });
+    it('returns CodexToolPermissionAdapter for codex', () => {
+        const adapter = createToolPermissionAdapter('codex');
+        expect(adapter).toBeInstanceOf(CodexToolPermissionAdapter);
+    });
+    it('returns ClaudeToolPermissionAdapter for amp (fallback)', () => {
+        const adapter = createToolPermissionAdapter('amp');
+        expect(adapter).toBeInstanceOf(ClaudeToolPermissionAdapter);
+    });
+    it('returns SpringAiToolPermissionAdapter for spring-ai', () => {
+        const adapter = createToolPermissionAdapter('spring-ai');
+        expect(adapter).toBeInstanceOf(SpringAiToolPermissionAdapter);
+    });
+    it('returns ClaudeToolPermissionAdapter for unknown provider', () => {
+        const adapter = createToolPermissionAdapter('unknown');
+        expect(adapter).toBeInstanceOf(ClaudeToolPermissionAdapter);
+    });
+    it('claude and codex adapters produce different output for same input', () => {
+        const claudeAdapter = createToolPermissionAdapter('claude');
+        const codexAdapter = createToolPermissionAdapter('codex');
+        const permissions = [{ shell: 'pnpm *' }];
+        const claudeResult = claudeAdapter.translatePermissions([...permissions]);
+        const codexResult = codexAdapter.translatePermissions([...permissions]);
+        expect(claudeResult).toEqual(['Bash(pnpm:*)']);
+        expect(codexResult).toEqual(['shell:pnpm *']);
+        expect(claudeResult).not.toEqual(codexResult);
+    });
+    it('all three provider adapters produce different output for shell permissions', () => {
+        const claudeAdapter = createToolPermissionAdapter('claude');
+        const codexAdapter = createToolPermissionAdapter('codex');
+        const springAiAdapter = createToolPermissionAdapter('spring-ai');
+        const permissions = [{ shell: 'pnpm *' }];
+        const claudeResult = claudeAdapter.translatePermissions([...permissions]);
+        const codexResult = codexAdapter.translatePermissions([...permissions]);
+        const springAiResult = springAiAdapter.translatePermissions([...permissions]);
+        expect(claudeResult).toEqual(['Bash(pnpm:*)']);
+        expect(codexResult).toEqual(['shell:pnpm *']);
+        expect(springAiResult).toEqual(['spring-tool:shell:pnpm *']);
+        // All three formats are distinct
+        expect(new Set([claudeResult[0], codexResult[0], springAiResult[0]]).size).toBe(3);
+    });
+});

package/dist/src/templates/agent-definition.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Agent Definition Parser
+ *
+ * Parses agent definition markdown files with YAML frontmatter.
+ * Supports configurable build/test/CLI commands in frontmatter that
+ * can be referenced in the body via Handlebars interpolation.
+ *
+ * Example frontmatter:
+ *   ---
+ *   name: developer
+ *   description: General-purpose development agent
+ *   tools: Read, Edit, Write, Grep, Glob, Bash
+ *   model: opus
+ *   build_commands:
+ *     verify: "cmake --build build-arm64/ --target engine-headless"
+ *     full: "cmake --build build-arm64/ --target engine-legacy"
+ *   test_commands:
+ *     unit: "cargo test"
+ *     integration: "cargo test -- --ignored"
+ *   af_linear: "bash tools/af-linear.sh"
+ *   ---
+ */
+import { z } from 'zod';
+/**
+ * Parsed frontmatter from an agent definition markdown file.
+ */
+export interface AgentDefinitionFrontmatter {
+    /** Agent name (e.g., "developer", "qa-reviewer") */
+    name: string;
+    /** When the orchestrator should select this agent */
+    description?: string;
+    /** Comma-separated list of allowed tools */
+    tools?: string;
+    /** Model to use (opus, sonnet, haiku) */
+    model?: string;
+    /** Named build commands (e.g., { verify: "cmake --build ...", full: "make all" }) */
+    build_commands?: Record<string, string>;
+    /** Named test commands (e.g., { unit: "cargo test", integration: "cargo test -- --ignored" }) */
+    test_commands?: Record<string, string>;
+    /** Custom Linear CLI command override (e.g., "bash tools/af-linear.sh") */
+    af_linear?: string;
+}
+/**
+ * Fully parsed agent definition with frontmatter and body.
+ */
+export interface AgentDefinition {
+    /** Parsed and validated frontmatter fields */
+    frontmatter: AgentDefinitionFrontmatter;
+    /** Raw markdown body (after frontmatter) */
+    rawBody: string;
+    /** Body rendered with frontmatter variables interpolated */
+    renderedBody: string;
+}
+export declare const AgentDefinitionFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodEnum<{
+        opus: "opus";
+        sonnet: "sonnet";
+        haiku: "haiku";
+    }>>;
+    build_commands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    test_commands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    af_linear: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Parse a markdown string with YAML frontmatter into an AgentDefinition.
+ *
+ * The body supports Handlebars interpolation for frontmatter fields:
+ *   - {{build_commands.verify}} → the "verify" build command
+ *   - {{test_commands.unit}} → the "unit" test command
+ *   - {{af_linear}} → the Linear CLI override
+ *   - {{name}}, {{description}}, {{model}} → basic fields
+ *
+ * @throws {Error} If frontmatter is malformed or fails validation
+ */
+export declare function parseAgentDefinition(content: string): AgentDefinition;
+/**
+ * Parse an agent definition from a file path.
+ *
+ * @throws {Error} If file cannot be read or parsed
+ */
+export declare function parseAgentDefinitionFile(filePath: string): AgentDefinition;
+//# sourceMappingURL=agent-definition.d.ts.map

package/dist/src/templates/agent-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-definition.d.ts","sourceRoot":"","sources":["../../../src/templates/agent-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,qDAAqD;IACrD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,qFAAqF;IACrF,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,iGAAiG;IACjG,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,WAAW,EAAE,0BAA0B,CAAA;IACvC,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAA;IACf,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAA;CACrB;AAMD,eAAO,MAAM,gCAAgC;;;;;;;;;;;;iBAQ3C,CAAA;AAQF;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAcrE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAQ1E"}

package/dist/src/templates/agent-definition.js

@@ -0,0 +1,97 @@
+/**
+ * Agent Definition Parser
+ *
+ * Parses agent definition markdown files with YAML frontmatter.
+ * Supports configurable build/test/CLI commands in frontmatter that
+ * can be referenced in the body via Handlebars interpolation.
+ *
+ * Example frontmatter:
+ *   ---
+ *   name: developer
+ *   description: General-purpose development agent
+ *   tools: Read, Edit, Write, Grep, Glob, Bash
+ *   model: opus
+ *   build_commands:
+ *     verify: "cmake --build build-arm64/ --target engine-headless"
+ *     full: "cmake --build build-arm64/ --target engine-legacy"
+ *   test_commands:
+ *     unit: "cargo test"
+ *     integration: "cargo test -- --ignored"
+ *   af_linear: "bash tools/af-linear.sh"
+ *   ---
+ */
+import fs from 'node:fs';
+import { parse as parseYaml } from 'yaml';
+import { z } from 'zod';
+import Handlebars from 'handlebars';
+// ---------------------------------------------------------------------------
+// Zod Schema
+// ---------------------------------------------------------------------------
+export const AgentDefinitionFrontmatterSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    tools: z.string().optional(),
+    model: z.enum(['opus', 'sonnet', 'haiku']).optional(),
+    build_commands: z.record(z.string(), z.string()).optional(),
+    test_commands: z.record(z.string(), z.string()).optional(),
+    af_linear: z.string().optional(),
+});
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/**
+ * Parse a markdown string with YAML frontmatter into an AgentDefinition.
+ *
+ * The body supports Handlebars interpolation for frontmatter fields:
+ *   - {{build_commands.verify}} → the "verify" build command
+ *   - {{test_commands.unit}} → the "unit" test command
+ *   - {{af_linear}} → the Linear CLI override
+ *   - {{name}}, {{description}}, {{model}} → basic fields
+ *
+ * @throws {Error} If frontmatter is malformed or fails validation
+ */
+export function parseAgentDefinition(content) {
+    const match = content.match(FRONTMATTER_RE);
+    if (!match) {
+        throw new Error('Agent definition must start with YAML frontmatter delimited by ---');
+    }
+    const [, yamlBlock, body] = match;
+    const parsed = parseYaml(yamlBlock);
+    const frontmatter = AgentDefinitionFrontmatterSchema.parse(parsed);
+    const rawBody = body.trimStart();
+    const renderedBody = renderBody(rawBody, frontmatter);
+    return { frontmatter, rawBody, renderedBody };
+}
+/**
+ * Parse an agent definition from a file path.
+ *
+ * @throws {Error} If file cannot be read or parsed
+ */
+export function parseAgentDefinitionFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    try {
+        return parseAgentDefinition(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse agent definition ${filePath}: ${message}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Body Rendering
+// ---------------------------------------------------------------------------
+/**
+ * Render the markdown body with frontmatter values as Handlebars context.
+ * Uses noEscape to preserve markdown formatting.
+ */
+function renderBody(body, frontmatter) {
+    try {
+        const template = Handlebars.compile(body, { noEscape: true });
+        return template(frontmatter);
+    }
+    catch {
+        // If body has no Handlebars expressions or they fail, return raw body
+        return body;
+    }
+}

package/dist/src/templates/agent-definition.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-definition.test.d.ts.map

package/dist/src/templates/agent-definition.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-definition.test.d.ts","sourceRoot":"","sources":["../../../src/templates/agent-definition.test.ts"],"names":[],"mappings":""}

package/dist/src/templates/agent-definition.test.js

@@ -0,0 +1,209 @@
+import { describe, it, expect } from 'vitest';
+import { parseAgentDefinition, AgentDefinitionFrontmatterSchema, } from './agent-definition.js';
+describe('AgentDefinitionFrontmatterSchema', () => {
+    it('validates a minimal frontmatter', () => {
+        const result = AgentDefinitionFrontmatterSchema.parse({ name: 'developer' });
+        expect(result.name).toBe('developer');
+        expect(result.build_commands).toBeUndefined();
+        expect(result.test_commands).toBeUndefined();
+        expect(result.af_linear).toBeUndefined();
+    });
+    it('validates a complete frontmatter', () => {
+        const result = AgentDefinitionFrontmatterSchema.parse({
+            name: 'developer',
+            description: 'General-purpose development agent',
+            tools: 'Read, Edit, Write, Grep, Glob, Bash',
+            model: 'opus',
+            build_commands: {
+                verify: 'cmake --build build/',
+                full: 'cmake --build build/ --target all',
+            },
+            test_commands: {
+                unit: 'ctest --test-dir build/',
+                integration: '',
+            },
+            af_linear: 'bash tools/af-linear.sh',
+        });
+        expect(result.name).toBe('developer');
+        expect(result.model).toBe('opus');
+        expect(result.build_commands).toEqual({
+            verify: 'cmake --build build/',
+            full: 'cmake --build build/ --target all',
+        });
+        expect(result.test_commands).toEqual({
+            unit: 'ctest --test-dir build/',
+            integration: '',
+        });
+        expect(result.af_linear).toBe('bash tools/af-linear.sh');
+    });
+    it('rejects invalid model', () => {
+        expect(() => AgentDefinitionFrontmatterSchema.parse({ name: 'test', model: 'gpt-4' })).toThrow();
+    });
+    it('rejects empty name', () => {
+        expect(() => AgentDefinitionFrontmatterSchema.parse({ name: '' })).toThrow();
+    });
+});
+describe('parseAgentDefinition', () => {
+    it('parses a simple agent definition', () => {
+        const content = `---
+name: developer
+description: Implements features
+tools: Read, Edit, Write
+model: opus
+---
+
+# Developer Agent
+
+Implements features and fixes bugs.
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.frontmatter.name).toBe('developer');
+        expect(result.frontmatter.description).toBe('Implements features');
+        expect(result.frontmatter.tools).toBe('Read, Edit, Write');
+        expect(result.frontmatter.model).toBe('opus');
+        expect(result.rawBody).toContain('# Developer Agent');
+        expect(result.renderedBody).toContain('# Developer Agent');
+    });
+    it('parses and interpolates build_commands in body', () => {
+        const content = `---
+name: developer
+build_commands:
+  verify: "cmake --build build/"
+  full: "make all"
+---
+
+## Build
+
+Verify build: \`{{build_commands.verify}}\`
+Full build: \`{{build_commands.full}}\`
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.frontmatter.build_commands).toEqual({
+            verify: 'cmake --build build/',
+            full: 'make all',
+        });
+        expect(result.renderedBody).toContain('Verify build: `cmake --build build/`');
+        expect(result.renderedBody).toContain('Full build: `make all`');
+    });
+    it('parses and interpolates test_commands in body', () => {
+        const content = `---
+name: qa
+test_commands:
+  unit: "cargo test"
+  integration: "cargo test -- --ignored"
+---
+
+Run unit tests: \`{{test_commands.unit}}\`
+Run integration tests: \`{{test_commands.integration}}\`
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.renderedBody).toContain('Run unit tests: `cargo test`');
+        expect(result.renderedBody).toContain('Run integration tests: `cargo test -- --ignored`');
+    });
+    it('parses and interpolates af_linear in body', () => {
+        const content = `---
+name: developer
+af_linear: "bash tools/af-linear.sh"
+---
+
+Use \`{{af_linear}}\` for all Linear operations.
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.renderedBody).toContain('Use `bash tools/af-linear.sh` for all Linear operations.');
+    });
+    it('preserves raw body without modifying it', () => {
+        const content = `---
+name: developer
+build_commands:
+  verify: "cmake --build build/"
+---
+
+Build: \`{{build_commands.verify}}\`
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.rawBody).toContain('{{build_commands.verify}}');
+        expect(result.renderedBody).toContain('cmake --build build/');
+    });
+    it('handles body with no Handlebars expressions', () => {
+        const content = `---
+name: developer
+tools: Read, Edit
+---
+
+# Simple Agent
+
+No interpolation here.
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.renderedBody).toContain('No interpolation here.');
+    });
+    it('handles empty build_commands gracefully', () => {
+        const content = `---
+name: developer
+build_commands: {}
+test_commands: {}
+---
+
+# Agent
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.frontmatter.build_commands).toEqual({});
+        expect(result.frontmatter.test_commands).toEqual({});
+    });
+    it('throws on missing frontmatter delimiters', () => {
+        const content = `# No frontmatter here
+
+Just a regular markdown file.
+`;
+        expect(() => parseAgentDefinition(content)).toThrow('must start with YAML frontmatter');
+    });
+    it('throws on invalid frontmatter schema', () => {
+        const content = `---
+model: gpt-4
+---
+
+# Agent
+`;
+        expect(() => parseAgentDefinition(content)).toThrow();
+    });
+    it('works with existing TypeScript agent definitions (backward compat)', () => {
+        // This mimics the existing developer.md format
+        const content = `---
+name: developer
+description: General-purpose development agent. Implements features, fixes bugs, and writes tests.
+tools: Read, Edit, Write, Grep, Glob, Bash
+model: opus
+---
+
+# Developer Agent
+
+Implements features and fixes bugs based on Linear issue requirements.
+
+## Testing
+
+\`\`\`bash
+pnpm turbo run test --filter=[package-name]
+pnpm turbo run typecheck --filter=[package-name]
+pnpm turbo run build --filter=[package-name]
+\`\`\`
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.frontmatter.name).toBe('developer');
+        expect(result.frontmatter.build_commands).toBeUndefined();
+        expect(result.frontmatter.test_commands).toBeUndefined();
+        expect(result.frontmatter.af_linear).toBeUndefined();
+        expect(result.renderedBody).toContain('pnpm turbo run test');
+    });
+    it('interpolates name and other basic fields in body', () => {
+        const content = `---
+name: my-agent
+description: A special agent
+model: sonnet
+---
+
+This is the {{name}} agent. Model: {{model}}.
+`;
+        const result = parseAgentDefinition(content);
+        expect(result.renderedBody).toContain('This is the my-agent agent. Model: sonnet.');
+    });
+});

package/dist/src/templates/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Workflow Template System
+ *
+ * Configurable, composable workflow templates using YAML with Handlebars.
+ */
+export type { WorkflowTemplate, PartialTemplate, TemplateContext, ToolPermission, ToolPermissionAdapter, TemplateRegistryConfig, } from './types.js';
+export { WorkflowTemplateSchema, PartialTemplateSchema, TemplateContextSchema, AgentWorkTypeSchema, ToolPermissionSchema, validateWorkflowTemplate, validatePartialTemplate, } from './types.js';
+export { TemplateRegistry } from './registry.js';
+export { loadTemplatesFromDir, loadTemplateFile, loadPartialsFromDir, getBuiltinDefaultsDir, getBuiltinPartialsDir, } from './loader.js';
+export { ClaudeToolPermissionAdapter, CodexToolPermissionAdapter, createToolPermissionAdapter } from './adapters.js';
+export { renderPromptWithFallback } from './renderer.js';
+export type { AgentDefinition, AgentDefinitionFrontmatter } from './agent-definition.js';
+export { parseAgentDefinition, parseAgentDefinitionFile, AgentDefinitionFrontmatterSchema } from './agent-definition.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAEhD,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA;AAEpH,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAExD,YAAY,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAA;AACxF,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/src/templates/index.js

@@ -0,0 +1,11 @@
+/**
+ * Workflow Template System
+ *
+ * Configurable, composable workflow templates using YAML with Handlebars.
+ */
+export { WorkflowTemplateSchema, PartialTemplateSchema, TemplateContextSchema, AgentWorkTypeSchema, ToolPermissionSchema, validateWorkflowTemplate, validatePartialTemplate, } from './types.js';
+export { TemplateRegistry } from './registry.js';
+export { loadTemplatesFromDir, loadTemplateFile, loadPartialsFromDir, getBuiltinDefaultsDir, getBuiltinPartialsDir, } from './loader.js';
+export { ClaudeToolPermissionAdapter, CodexToolPermissionAdapter, createToolPermissionAdapter } from './adapters.js';
+export { renderPromptWithFallback } from './renderer.js';
+export { parseAgentDefinition, parseAgentDefinitionFile, AgentDefinitionFrontmatterSchema } from './agent-definition.js';

package/dist/src/templates/loader.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Template Loader
+ *
+ * Discovers, parses, and validates workflow templates from YAML files.
+ * Supports layered resolution:
+ *   1. Built-in defaults (packages/core/src/templates/defaults/)
+ *   2. Project-level overrides (.agentfactory/templates/ in repo root)
+ *   3. Inline config overrides (programmatic)
+ */
+import type { WorkflowTemplate } from './types.js';
+/**
+ * Load all workflow templates from a directory.
+ * Only processes .yaml and .yml files at the top level.
+ *
+ * The map key is determined by `metadata.name` when it differs from `metadata.workType`,
+ * enabling strategy-specific compound keys like "refinement-context-enriched".
+ * When `metadata.name` equals `metadata.workType`, the key is simply the work type.
+ */
+export declare function loadTemplatesFromDir(dir: string): Map<string, WorkflowTemplate>;
+/**
+ * Load and validate a single workflow template YAML file.
+ */
+export declare function loadTemplateFile(filePath: string): WorkflowTemplate | null;
+/**
+ * Load all partial templates from a directory (including subdirectories).
+ * Returns a map of partial name → content string.
+ *
+ * Partial names are derived from file paths relative to the partials directory:
+ *   partials/cli-instructions.yaml → "cli-instructions"
+ *   partials/frontend/linear-cli.yaml → "frontend/linear-cli"
+ */
+export declare function loadPartialsFromDir(dir: string, frontend?: string): Map<string, string>;
+/**
+ * Get the path to the built-in default templates directory.
+ */
+export declare function getBuiltinDefaultsDir(): string;
+/**
+ * Get the path to the built-in default partials directory.
+ */
+export declare function getBuiltinPartialsDir(): string;
+//# sourceMappingURL=loader.d.ts.map

package/dist/src/templates/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/templates/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,YAAY,CAAA;AAGnE;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAyB/E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAS1E;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,GAChB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CASrB;AA4CD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAG9C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C"}