@renseiai/agentfactory 0.8.0

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

@@ -0,0 +1,233 @@
+/**
+ * Workflow Template Types
+ *
+ * TypeScript interfaces and Zod schemas for the YAML-based workflow template system.
+ * Templates use Handlebars for interpolation and partials for composability.
+ *
+ * Architecture decisions (from SUP-701):
+ * - YAML format with Handlebars interpolation (not custom parser)
+ * - Single flat `prompt` field (not sectioned)
+ * - State transitions stay in TypeScript (not in templates)
+ * - Schema versioning: apiVersion: v1
+ * - Provider-agnostic tool permissions
+ * - Frontend-specific content in partials only
+ */
+import { z } from 'zod';
+import type { AgentWorkType } from '@renseiai/agentfactory-linear';
+export type { AgentWorkType } from '@renseiai/agentfactory-linear';
+/**
+ * Provider-agnostic tool permission.
+ *
+ * Shell permissions specify command patterns (e.g., "pnpm *").
+ * Provider adapters translate these to native format:
+ *   - Claude: { shell: "pnpm *" } → "Bash(pnpm:*)"
+ *   - Other providers: their own format
+ */
+export type ToolPermission = {
+    shell: string;
+} | 'user-input' | string;
+/**
+ * A workflow template defines the prompt and tool permissions for a work type.
+ */
+export interface WorkflowTemplate {
+    apiVersion: 'v1';
+    kind: 'WorkflowTemplate';
+    metadata: {
+        name: string;
+        description?: string;
+        workType: AgentWorkType;
+    };
+    tools?: {
+        allow?: ToolPermission[];
+        disallow?: ToolPermission[];
+    };
+    /** Handlebars template string rendered with TemplateContext variables */
+    prompt: string;
+}
+/**
+ * A reusable instruction block that can be composed into workflow templates
+ * via Handlebars partials: {{> partials/name}}
+ */
+export interface PartialTemplate {
+    apiVersion: 'v1';
+    kind: 'PartialTemplate';
+    metadata: {
+        name: string;
+        description?: string;
+        /** If set, this partial is frontend-specific (e.g., "linear", "asana") */
+        frontend?: string;
+    };
+    /** Handlebars template string (may reference other partials) */
+    content: string;
+}
+/**
+ * Variables available for interpolation in workflow templates.
+ */
+export interface TemplateContext {
+    /** Issue identifier, e.g., "SUP-123" */
+    identifier: string;
+    /** Optional user mention text providing additional context */
+    mentionContext?: string;
+    /** Status to show when agent starts, e.g., "Started" (Linear) */
+    startStatus?: string;
+    /** Status to show when agent completes, e.g., "Finished" */
+    completeStatus?: string;
+    /** Pre-built enriched prompt for parent issues with sub-issues */
+    parentContext?: string;
+    /** Formatted list of sub-issues with statuses */
+    subIssueList?: string;
+    /** Current escalation cycle count (from WorkflowState) */
+    cycleCount?: number;
+    /** Current escalation strategy: 'normal' | 'context-enriched' | 'decompose' | 'escalate-human' */
+    strategy?: string;
+    /** Accumulated failure summary across cycles */
+    failureSummary?: string;
+    /** Attempt number within current phase */
+    attemptNumber?: number;
+    /** List of previous failure reasons */
+    previousFailureReasons?: string[];
+    /** Total cost in USD across all attempts */
+    totalCostUsd?: number;
+    /** Blocker issue identifier (for escalation alerts) */
+    blockerIdentifier?: string;
+    /** Team name (for decomposition sub-issue creation) */
+    team?: string;
+    /** Git repository URL pattern for pre-push validation (e.g. 'github.com/org/repo') */
+    repository?: string;
+    /** Root directory for this project within the repo (e.g. 'apps/family') */
+    projectPath?: string;
+    /** Shared directories that any project's agent may modify (e.g. ['packages/ui']) */
+    sharedPaths?: string[];
+    /** When true, agents use in-process af_linear_* tools instead of CLI */
+    useToolPlugins?: boolean;
+    /** Command to invoke the Linear CLI (default: "pnpm af-linear") */
+    linearCli?: string;
+    /** Package manager used by the project (default: "pnpm"). Set to "none" for non-Node projects. */
+    packageManager?: string;
+    /** Build command override (e.g. 'cargo build', 'cmake --build build', 'make') */
+    buildCommand?: string;
+    /** Test command override (e.g. 'cargo test', 'ctest --test-dir build', 'make test') */
+    testCommand?: string;
+    /** Validation command override — replaces typecheck for compiled projects (e.g. 'cargo clippy') */
+    validateCommand?: string;
+}
+/**
+ * Translates abstract tool permissions to provider-native format.
+ *
+ * Example: Claude adapter translates { shell: "pnpm *" } → "Bash(pnpm:*)"
+ */
+export interface ToolPermissionAdapter {
+    /** Translate abstract permissions to provider-native format */
+    translatePermissions(permissions: ToolPermission[]): string[];
+}
+/**
+ * Configuration for creating a template registry.
+ */
+export interface TemplateRegistryConfig {
+    /** Directories to scan for template YAML files (searched in order) */
+    templateDirs?: string[];
+    /**
+     * Inline template overrides (highest priority).
+     * Keys can be AgentWorkType values (e.g., "development") or strategy-specific
+     * compound keys (e.g., "refinement-context-enriched").
+     */
+    templates?: Partial<Record<AgentWorkType, WorkflowTemplate>> & Record<string, WorkflowTemplate>;
+    /** Whether to load built-in defaults (default: true) */
+    useBuiltinDefaults?: boolean;
+    /** Frontend discriminator for partial resolution (e.g., "linear", "asana") */
+    frontend?: string;
+    /** Provider discriminator for tool permission translation */
+    provider?: string;
+}
+export declare const AgentWorkTypeSchema: z.ZodEnum<{
+    research: "research";
+    "backlog-creation": "backlog-creation";
+    development: "development";
+    inflight: "inflight";
+    qa: "qa";
+    acceptance: "acceptance";
+    refinement: "refinement";
+    "refinement-coordination": "refinement-coordination";
+    coordination: "coordination";
+    "qa-coordination": "qa-coordination";
+    "acceptance-coordination": "acceptance-coordination";
+}>;
+export declare const ToolPermissionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    shell: z.ZodString;
+}, z.core.$strip>, z.ZodLiteral<"user-input">, z.ZodString]>;
+export declare const WorkflowTemplateSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"v1">;
+    kind: z.ZodLiteral<"WorkflowTemplate">;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        workType: z.ZodEnum<{
+            research: "research";
+            "backlog-creation": "backlog-creation";
+            development: "development";
+            inflight: "inflight";
+            qa: "qa";
+            acceptance: "acceptance";
+            refinement: "refinement";
+            "refinement-coordination": "refinement-coordination";
+            coordination: "coordination";
+            "qa-coordination": "qa-coordination";
+            "acceptance-coordination": "acceptance-coordination";
+        }>;
+    }, z.core.$strip>;
+    tools: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            shell: z.ZodString;
+        }, z.core.$strip>, z.ZodLiteral<"user-input">, z.ZodString]>>>;
+        disallow: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            shell: z.ZodString;
+        }, z.core.$strip>, z.ZodLiteral<"user-input">, z.ZodString]>>>;
+    }, z.core.$strip>>;
+    prompt: z.ZodString;
+}, z.core.$strip>;
+export declare const PartialTemplateSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"v1">;
+    kind: z.ZodLiteral<"PartialTemplate">;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        frontend: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const TemplateContextSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    mentionContext: z.ZodOptional<z.ZodString>;
+    startStatus: z.ZodOptional<z.ZodString>;
+    completeStatus: z.ZodOptional<z.ZodString>;
+    parentContext: z.ZodOptional<z.ZodString>;
+    subIssueList: z.ZodOptional<z.ZodString>;
+    cycleCount: z.ZodOptional<z.ZodNumber>;
+    strategy: z.ZodOptional<z.ZodString>;
+    failureSummary: z.ZodOptional<z.ZodString>;
+    attemptNumber: z.ZodOptional<z.ZodNumber>;
+    previousFailureReasons: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    totalCostUsd: z.ZodOptional<z.ZodNumber>;
+    blockerIdentifier: z.ZodOptional<z.ZodString>;
+    team: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    projectPath: z.ZodOptional<z.ZodString>;
+    sharedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    useToolPlugins: z.ZodOptional<z.ZodBoolean>;
+    linearCli: z.ZodOptional<z.ZodString>;
+    packageManager: z.ZodOptional<z.ZodString>;
+    buildCommand: z.ZodOptional<z.ZodString>;
+    testCommand: z.ZodOptional<z.ZodString>;
+    validateCommand: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Validate a parsed YAML object as a WorkflowTemplate.
+ * Throws ZodError with detailed messages on failure.
+ */
+export declare function validateWorkflowTemplate(data: unknown, filePath?: string): WorkflowTemplate;
+/**
+ * Validate a parsed YAML object as a PartialTemplate.
+ * Throws ZodError with detailed messages on failure.
+ */
+export declare function validatePartialTemplate(data: unknown, filePath?: string): PartialTemplate;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/templates/types.ts"],"names":[],"mappings":"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"}

package/dist/src/templates/types.js

@@ -0,0 +1,127 @@
+/**
+ * Workflow Template Types
+ *
+ * TypeScript interfaces and Zod schemas for the YAML-based workflow template system.
+ * Templates use Handlebars for interpolation and partials for composability.
+ *
+ * Architecture decisions (from SUP-701):
+ * - YAML format with Handlebars interpolation (not custom parser)
+ * - Single flat `prompt` field (not sectioned)
+ * - State transitions stay in TypeScript (not in templates)
+ * - Schema versioning: apiVersion: v1
+ * - Provider-agnostic tool permissions
+ * - Frontend-specific content in partials only
+ */
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Zod Schemas
+// ---------------------------------------------------------------------------
+/** All valid work type values */
+const WORK_TYPES = [
+    'research',
+    'backlog-creation',
+    'development',
+    'inflight',
+    'qa',
+    'acceptance',
+    'refinement',
+    'refinement-coordination',
+    'coordination',
+    'qa-coordination',
+    'acceptance-coordination',
+];
+export const AgentWorkTypeSchema = z.enum(WORK_TYPES);
+export const ToolPermissionSchema = z.union([
+    z.object({ shell: z.string().min(1) }),
+    z.literal('user-input'),
+    z.string().min(1),
+]);
+export const WorkflowTemplateSchema = z.object({
+    apiVersion: z.literal('v1'),
+    kind: z.literal('WorkflowTemplate'),
+    metadata: z.object({
+        name: z.string().min(1),
+        description: z.string().optional(),
+        workType: AgentWorkTypeSchema,
+    }),
+    tools: z.object({
+        allow: z.array(ToolPermissionSchema).optional(),
+        disallow: z.array(ToolPermissionSchema).optional(),
+    }).optional(),
+    prompt: z.string().min(1),
+});
+export const PartialTemplateSchema = z.object({
+    apiVersion: z.literal('v1'),
+    kind: z.literal('PartialTemplate'),
+    metadata: z.object({
+        name: z.string().min(1),
+        description: z.string().optional(),
+        frontend: z.string().optional(),
+    }),
+    content: z.string().min(1),
+});
+export const TemplateContextSchema = z.object({
+    identifier: z.string().min(1),
+    mentionContext: z.string().optional(),
+    startStatus: z.string().optional(),
+    completeStatus: z.string().optional(),
+    parentContext: z.string().optional(),
+    subIssueList: z.string().optional(),
+    // Strategy / WorkflowState variables
+    cycleCount: z.number().int().nonnegative().optional(),
+    strategy: z.string().optional(),
+    failureSummary: z.string().optional(),
+    attemptNumber: z.number().int().positive().optional(),
+    previousFailureReasons: z.array(z.string()).optional(),
+    totalCostUsd: z.number().nonnegative().optional(),
+    // Governor notification variables
+    blockerIdentifier: z.string().optional(),
+    team: z.string().optional(),
+    // Repository validation variables
+    repository: z.string().optional(),
+    // Project path scoping variables (monorepo support)
+    projectPath: z.string().optional(),
+    sharedPaths: z.array(z.string()).optional(),
+    // Tool plugin mode
+    useToolPlugins: z.boolean().optional(),
+    // Non-Node project support
+    linearCli: z.string().optional(),
+    packageManager: z.string().optional(),
+    // Configurable build/test commands (native/compiled project support)
+    buildCommand: z.string().optional(),
+    testCommand: z.string().optional(),
+    validateCommand: z.string().optional(),
+});
+// ---------------------------------------------------------------------------
+// Validation Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Validate a parsed YAML object as a WorkflowTemplate.
+ * Throws ZodError with detailed messages on failure.
+ */
+export function validateWorkflowTemplate(data, filePath) {
+    try {
+        return WorkflowTemplateSchema.parse(data);
+    }
+    catch (error) {
+        if (filePath && error instanceof z.ZodError) {
+            throw new Error(`Invalid workflow template at ${filePath}: ${error.message}`, { cause: error });
+        }
+        throw error;
+    }
+}
+/**
+ * Validate a parsed YAML object as a PartialTemplate.
+ * Throws ZodError with detailed messages on failure.
+ */
+export function validatePartialTemplate(data, filePath) {
+    try {
+        return PartialTemplateSchema.parse(data);
+    }
+    catch (error) {
+        if (filePath && error instanceof z.ZodError) {
+            throw new Error(`Invalid partial template at ${filePath}: ${error.message}`, { cause: error });
+        }
+        throw error;
+    }
+}

package/dist/src/templates/types.test.d.ts

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

package/dist/src/templates/types.test.d.ts.map

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

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

@@ -0,0 +1,232 @@
+import { describe, it, expect } from 'vitest';
+import { WorkflowTemplateSchema, PartialTemplateSchema, TemplateContextSchema, AgentWorkTypeSchema, ToolPermissionSchema, validateWorkflowTemplate, validatePartialTemplate, } from './types.js';
+describe('WorkflowTemplateSchema', () => {
+    it('validates a complete workflow template', () => {
+        const template = {
+            apiVersion: 'v1',
+            kind: 'WorkflowTemplate',
+            metadata: {
+                name: 'development',
+                description: 'Standard development workflow',
+                workType: 'development',
+            },
+            tools: {
+                allow: [
+                    { shell: 'pnpm *' },
+                    { shell: 'git commit *' },
+                ],
+                disallow: ['user-input'],
+            },
+            prompt: 'Start work on {{identifier}}.',
+        };
+        const result = WorkflowTemplateSchema.parse(template);
+        expect(result.apiVersion).toBe('v1');
+        expect(result.metadata.workType).toBe('development');
+        expect(result.tools?.allow).toHaveLength(2);
+    });
+    it('validates a minimal workflow template', () => {
+        const template = {
+            apiVersion: 'v1',
+            kind: 'WorkflowTemplate',
+            metadata: {
+                name: 'research',
+                workType: 'research',
+            },
+            prompt: 'Research {{identifier}}.',
+        };
+        const result = WorkflowTemplateSchema.parse(template);
+        expect(result.metadata.name).toBe('research');
+        expect(result.tools).toBeUndefined();
+    });
+    it('rejects invalid apiVersion', () => {
+        const template = {
+            apiVersion: 'v2',
+            kind: 'WorkflowTemplate',
+            metadata: { name: 'test', workType: 'development' },
+            prompt: 'test',
+        };
+        expect(() => WorkflowTemplateSchema.parse(template)).toThrow();
+    });
+    it('rejects invalid workType', () => {
+        const template = {
+            apiVersion: 'v1',
+            kind: 'WorkflowTemplate',
+            metadata: { name: 'test', workType: 'invalid' },
+            prompt: 'test',
+        };
+        expect(() => WorkflowTemplateSchema.parse(template)).toThrow();
+    });
+    it('rejects empty prompt', () => {
+        const template = {
+            apiVersion: 'v1',
+            kind: 'WorkflowTemplate',
+            metadata: { name: 'test', workType: 'development' },
+            prompt: '',
+        };
+        expect(() => WorkflowTemplateSchema.parse(template)).toThrow();
+    });
+});
+describe('PartialTemplateSchema', () => {
+    it('validates a partial template', () => {
+        const partial = {
+            apiVersion: 'v1',
+            kind: 'PartialTemplate',
+            metadata: {
+                name: 'cli-instructions',
+                description: 'CLI instructions',
+            },
+            content: 'Use pnpm af-linear for all operations.',
+        };
+        const result = PartialTemplateSchema.parse(partial);
+        expect(result.metadata.name).toBe('cli-instructions');
+        expect(result.metadata.frontend).toBeUndefined();
+    });
+    it('validates a frontend-specific partial', () => {
+        const partial = {
+            apiVersion: 'v1',
+            kind: 'PartialTemplate',
+            metadata: {
+                name: 'linear-cli',
+                frontend: 'linear',
+            },
+            content: 'pnpm af-linear get-issue <id>',
+        };
+        const result = PartialTemplateSchema.parse(partial);
+        expect(result.metadata.frontend).toBe('linear');
+    });
+    it('rejects empty content', () => {
+        const partial = {
+            apiVersion: 'v1',
+            kind: 'PartialTemplate',
+            metadata: { name: 'test' },
+            content: '',
+        };
+        expect(() => PartialTemplateSchema.parse(partial)).toThrow();
+    });
+});
+describe('AgentWorkTypeSchema', () => {
+    it('accepts all 10 work types', () => {
+        const workTypes = [
+            'research', 'backlog-creation', 'development', 'inflight',
+            'qa', 'acceptance', 'refinement', 'coordination',
+            'qa-coordination', 'acceptance-coordination',
+        ];
+        for (const wt of workTypes) {
+            expect(AgentWorkTypeSchema.parse(wt)).toBe(wt);
+        }
+    });
+    it('rejects invalid work type', () => {
+        expect(() => AgentWorkTypeSchema.parse('invalid')).toThrow();
+    });
+});
+describe('ToolPermissionSchema', () => {
+    it('accepts shell permission', () => {
+        expect(ToolPermissionSchema.parse({ shell: 'pnpm *' })).toEqual({ shell: 'pnpm *' });
+    });
+    it('accepts user-input literal', () => {
+        expect(ToolPermissionSchema.parse('user-input')).toBe('user-input');
+    });
+    it('accepts string permission', () => {
+        expect(ToolPermissionSchema.parse('Read')).toBe('Read');
+    });
+});
+describe('TemplateContextSchema', () => {
+    it('validates minimal context', () => {
+        const result = TemplateContextSchema.parse({ identifier: 'SUP-123' });
+        expect(result.identifier).toBe('SUP-123');
+    });
+    it('validates full context', () => {
+        const result = TemplateContextSchema.parse({
+            identifier: 'SUP-123',
+            mentionContext: 'user mention',
+            startStatus: 'Started',
+            completeStatus: 'Finished',
+            parentContext: 'parent context',
+            subIssueList: '- SUP-124: Sub 1',
+        });
+        expect(result.mentionContext).toBe('user mention');
+    });
+    it('validates context with strategy/WorkflowState fields', () => {
+        const result = TemplateContextSchema.parse({
+            identifier: 'SUP-123',
+            cycleCount: 3,
+            strategy: 'context-enriched',
+            failureSummary: 'Tests failing on auth module',
+            attemptNumber: 2,
+            previousFailureReasons: ['reason1', 'reason2'],
+            totalCostUsd: 1.50,
+            blockerIdentifier: 'SUP-999',
+            team: 'Engineering',
+        });
+        expect(result.cycleCount).toBe(3);
+        expect(result.strategy).toBe('context-enriched');
+        expect(result.failureSummary).toBe('Tests failing on auth module');
+        expect(result.attemptNumber).toBe(2);
+        expect(result.previousFailureReasons).toEqual(['reason1', 'reason2']);
+        expect(result.totalCostUsd).toBe(1.50);
+        expect(result.blockerIdentifier).toBe('SUP-999');
+        expect(result.team).toBe('Engineering');
+    });
+    it('rejects negative cycleCount', () => {
+        expect(() => TemplateContextSchema.parse({
+            identifier: 'SUP-123',
+            cycleCount: -1,
+        })).toThrow();
+    });
+    it('rejects non-positive attemptNumber', () => {
+        expect(() => TemplateContextSchema.parse({
+            identifier: 'SUP-123',
+            attemptNumber: 0,
+        })).toThrow();
+    });
+    it('rejects negative totalCostUsd', () => {
+        expect(() => TemplateContextSchema.parse({
+            identifier: 'SUP-123',
+            totalCostUsd: -5,
+        })).toThrow();
+    });
+    it('rejects empty identifier', () => {
+        expect(() => TemplateContextSchema.parse({ identifier: '' })).toThrow();
+    });
+    it('validates context with build/test command variables', () => {
+        const result = TemplateContextSchema.parse({
+            identifier: 'SUP-123',
+            buildCommand: 'cargo build --release',
+            testCommand: 'cargo test',
+            validateCommand: 'cargo clippy -- -D warnings',
+        });
+        expect(result.buildCommand).toBe('cargo build --release');
+        expect(result.testCommand).toBe('cargo test');
+        expect(result.validateCommand).toBe('cargo clippy -- -D warnings');
+    });
+    it('allows omitting build/test command variables', () => {
+        const result = TemplateContextSchema.parse({
+            identifier: 'SUP-123',
+        });
+        expect(result.buildCommand).toBeUndefined();
+        expect(result.testCommand).toBeUndefined();
+        expect(result.validateCommand).toBeUndefined();
+    });
+});
+describe('validateWorkflowTemplate', () => {
+    it('adds file path to error message', () => {
+        try {
+            validateWorkflowTemplate({ invalid: true }, '/path/to/file.yaml');
+            expect.fail('should throw');
+        }
+        catch (error) {
+            expect(error.message).toContain('/path/to/file.yaml');
+        }
+    });
+});
+describe('validatePartialTemplate', () => {
+    it('adds file path to error message', () => {
+        try {
+            validatePartialTemplate({ invalid: true }, '/path/to/partial.yaml');
+            expect.fail('should throw');
+        }
+        catch (error) {
+            expect(error.message).toContain('/path/to/partial.yaml');
+        }
+    });
+});

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

@@ -0,0 +1,6 @@
+export { ToolRegistry } from './registry.js';
+export type { ToolPlugin, ToolPluginContext } from './types.js';
+export { linearPlugin } from './plugins/linear.js';
+export { runLinear, parseLinearArgs } from './linear-runner.js';
+export type { LinearRunnerConfig, LinearRunnerResult } from './linear-runner.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAC/D,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/src/tools/index.js

@@ -0,0 +1,3 @@
+export { ToolRegistry } from './registry.js';
+export { linearPlugin } from './plugins/linear.js';
+export { runLinear, parseLinearArgs } from './linear-runner.js';

package/dist/src/tools/linear-runner.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Linear CLI Runner — process-agnostic Linear operations.
+ *
+ * All 16 command implementations. This module does NOT call process.exit,
+ * read process.argv, or load dotenv. Shared by both the CLI entry point
+ * and the in-process tool plugin.
+ */
+export interface LinearRunnerConfig {
+    command: string;
+    args: Record<string, string | string[] | boolean>;
+    positionalArgs: string[];
+    apiKey?: string;
+}
+export interface LinearRunnerResult {
+    output: unknown;
+}
+/**
+ * Parse CLI arguments into a structured object.
+ *
+ * Supports:
+ * - `--key value` pairs
+ * - JSON array values: `--labels '["Bug", "Feature"]'`
+ * - Comma-separated values for array fields: `--labels "Bug,Feature"`
+ * - Boolean flags: `--dry-run` (value = "true")
+ *
+ * Returns the command (first non-flag arg), named args, and positional args.
+ */
+export declare function parseLinearArgs(argv: string[]): {
+    command: string | undefined;
+    args: Record<string, string | string[] | boolean>;
+    positionalArgs: string[];
+};
+export declare function runLinear(config: LinearRunnerConfig): Promise<LinearRunnerResult>;
+//# sourceMappingURL=linear-runner.d.ts.map

package/dist/src/tools/linear-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-runner.d.ts","sourceRoot":"","sources":["../../../src/tools/linear-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,CAAA;CAChB;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAC/C,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;CACzB,CA2CA;AA0nBD,wBAAsB,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAyNvF"}