@helmiq/crew 0.1.0

package/dist/tools/registry.js

@@ -0,0 +1,288 @@
+/**
+ * CrewTool registry -- maps logical tool names used in persona specs
+ * to executable CrewTool implementations backed by the tool packages.
+ *
+ * Each tool's `execute` function adapts the tool package's API,
+ * injecting ToolExecutionContext values (repo paths, protected paths, etc.)
+ * so the LLM only needs to provide the operation-specific parameters.
+ */
+import { readFileFromRepo, writeFileToRepo, listDirectory, searchCodebase, } from '@helmiq/crew-code';
+import { gitBranch, gitCommit, gitPush, gitDiff, gitLog, createPr } from '@helmiq/crew-git';
+import { runCommand, createAllowlist } from '@helmiq/crew-shell';
+export function createToolRegistry(options) {
+    const registry = {
+        'read-file': {
+            name: 'read-file',
+            description: 'Read a file from the target repository',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative file path within the repository' },
+                },
+                required: ['path'],
+            },
+            execute: async (params, ctx) => {
+                const { path } = params;
+                return readFileFromRepo({ path }, ctx.targetRepoPath);
+            },
+        },
+        'write-file': {
+            name: 'write-file',
+            description: 'Write or create a file in the target repository',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative file path within the repository' },
+                    content: { type: 'string', description: 'File content to write' },
+                },
+                required: ['path', 'content'],
+            },
+            execute: async (params, ctx) => {
+                const { path, content } = params;
+                return writeFileToRepo({ path, content }, ctx.targetRepoPath, ctx.protectedPaths);
+            },
+        },
+        'list-directory': {
+            name: 'list-directory',
+            description: 'List files and directories in the target repository',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative directory path (default: repository root)',
+                    },
+                },
+            },
+            execute: async (params, ctx) => {
+                const { path } = (params ?? {});
+                return listDirectory({ path }, ctx.targetRepoPath);
+            },
+        },
+        'search-codebase': {
+            name: 'search-codebase',
+            description: 'Search the target repository for text patterns',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Search pattern (regex)' },
+                    glob: { type: 'string', description: 'File glob filter (e.g. "*.ts")' },
+                    maxResults: { type: 'number', description: 'Maximum results to return' },
+                },
+                required: ['pattern'],
+            },
+            execute: async (params, ctx) => {
+                const { pattern, glob, maxResults } = params;
+                return searchCodebase({ pattern, glob, maxResults }, ctx.targetRepoPath);
+            },
+        },
+        'git-branch': {
+            name: 'git-branch',
+            description: 'Create and checkout a new Git branch in the target repository',
+            parameters: {
+                type: 'object',
+                properties: {
+                    branchName: { type: 'string', description: 'Name of the branch to create' },
+                },
+                required: ['branchName'],
+            },
+            execute: async (params, ctx) => {
+                const { branchName } = params;
+                const convention = ctx.project.project.key
+                    ? `^feat/${ctx.project.project.key}-`
+                    : undefined;
+                return gitBranch({ branchName }, ctx.targetRepoPath, convention);
+            },
+        },
+        'git-commit': {
+            name: 'git-commit',
+            description: 'Stage files and create a commit in the target repository',
+            parameters: {
+                type: 'object',
+                properties: {
+                    filePaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Files to stage and commit',
+                    },
+                    message: { type: 'string', description: 'Commit message' },
+                },
+                required: ['filePaths', 'message'],
+            },
+            execute: async (params, ctx) => {
+                const { filePaths, message } = params;
+                return gitCommit({ filePaths, message }, ctx.targetRepoPath);
+            },
+        },
+        'git-push': {
+            name: 'git-push',
+            description: 'Push the current branch to the remote',
+            parameters: {
+                type: 'object',
+                properties: {
+                    branch: { type: 'string', description: 'Branch to push (default: current)' },
+                },
+            },
+            execute: async (params, ctx) => {
+                const { branch } = (params ?? {});
+                return gitPush({ branch }, ctx.targetRepoPath);
+            },
+        },
+        'git-diff': {
+            name: 'git-diff',
+            description: 'Show the diff of changes in the target repository',
+            parameters: {
+                type: 'object',
+                properties: {
+                    staged: { type: 'boolean', description: 'Show staged changes only' },
+                    paths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Limit diff to specific files',
+                    },
+                },
+            },
+            execute: async (params, ctx) => {
+                const { staged, paths } = (params ?? {});
+                return gitDiff({ staged, paths }, ctx.targetRepoPath);
+            },
+        },
+        'git-log': {
+            name: 'git-log',
+            description: 'Show recent commit log in the target repository',
+            parameters: {
+                type: 'object',
+                properties: {
+                    maxCount: { type: 'number', description: 'Maximum number of entries' },
+                    path: { type: 'string', description: 'Limit to commits affecting this path' },
+                },
+            },
+            execute: async (params, ctx) => {
+                const { maxCount, path } = (params ?? {});
+                return gitLog({ maxCount, path }, ctx.targetRepoPath);
+            },
+        },
+        'create-pr': {
+            name: 'create-pr',
+            description: 'Create a GitHub pull request. The branch must be pushed to the remote first using git-push; creation will fail if the branch does not exist on the remote.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string', description: 'PR title' },
+                    body: { type: 'string', description: 'PR description' },
+                    head: { type: 'string', description: 'Source branch' },
+                    base: { type: 'string', description: 'Target branch (default: main)' },
+                    labels: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Labels to apply',
+                    },
+                },
+                required: ['title', 'body', 'head'],
+            },
+            execute: async (params, ctx) => {
+                const { title, body, head, base, labels } = params;
+                const [owner, repo] = ctx.project.source.repo.replace('github:', '').split('/');
+                return createPr({
+                    owner: owner,
+                    repo: repo,
+                    title,
+                    body,
+                    head,
+                    base: base ?? 'main',
+                    labels,
+                });
+            },
+        },
+        'run-command': {
+            name: 'run-command',
+            description: 'Run a shell command in the target repository (restricted to allowlisted commands)',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'Command to run (e.g. pnpm)' },
+                    args: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Command arguments (e.g. ["test"])',
+                    },
+                    cwd: { type: 'string', description: 'Working directory relative to repo root' },
+                },
+                required: ['command', 'args'],
+            },
+            execute: async (params, ctx) => {
+                const { command, args, cwd } = params;
+                const rules = createAllowlist();
+                return runCommand({ command, args, cwd }, ctx.targetRepoPath, rules);
+            },
+        },
+    };
+    if (options?.artifactStore) {
+        const store = options.artifactStore;
+        registry['read-artifact'] = {
+            name: 'read-artifact',
+            description: 'Read a delivery artifact (requirements, design, review, standards) from the workspace',
+            parameters: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        description: 'Artifact type (e.g. requirements, design, review, standards, backlog)',
+                    },
+                    scope: {
+                        type: 'object',
+                        description: 'Scope variables for path resolution (e.g. { "epic": "CREW-03" })',
+                        additionalProperties: { type: 'string' },
+                    },
+                },
+                required: ['type', 'scope'],
+            },
+            execute: async (params) => {
+                const { type, scope } = params;
+                const result = await store.read(type, scope);
+                if (!result) {
+                    return { found: false, type, scope };
+                }
+                return {
+                    found: true,
+                    path: result.path,
+                    content: result.content,
+                    frontmatter: result.frontmatter,
+                };
+            },
+        };
+        registry['write-artifact'] = {
+            name: 'write-artifact',
+            description: 'Write a delivery artifact to the workspace',
+            parameters: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        description: 'Artifact type (e.g. review, design)',
+                    },
+                    scope: {
+                        type: 'object',
+                        description: 'Scope variables for path resolution (e.g. { "epic": "CREW-03" })',
+                        additionalProperties: { type: 'string' },
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Markdown content to write',
+                    },
+                    frontmatter: {
+                        type: 'object',
+                        description: 'YAML frontmatter metadata',
+                        additionalProperties: true,
+                    },
+                },
+                required: ['type', 'scope', 'content'],
+            },
+            execute: async (params) => {
+                const { type, scope, content, frontmatter } = params;
+                return store.write(type, scope, content, frontmatter ?? {});
+            },
+        };
+    }
+    return registry;
+}

package/dist/tools/registry.test.d.ts

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

package/dist/tools/registry.test.d.ts.map

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

package/dist/tools/registry.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createToolRegistry } from './registry.js';
+const mockContext = {
+    workspacePath: '/tmp/ws',
+    targetRepoPath: '/tmp/target',
+    project: {
+        project: { name: 'test', key: 'T' },
+        workspace: { path: '/tmp/ws', work: 'work/{EPIC_ID}', runs: 'runs' },
+        source: { repo: 'github:test/repo', path: '/tmp/target' },
+        llm: { default_model: 'test', providers: {} },
+    },
+    persona: 'engineer',
+    task: 'implement-story',
+    runId: 'run-test-001',
+    protectedPaths: [],
+    logger: () => { },
+};
+describe('createToolRegistry', () => {
+    it('registers all code, git, and shell tools', () => {
+        const registry = createToolRegistry();
+        const names = Object.keys(registry).sort();
+        expect(names).toEqual([
+            'create-pr',
+            'git-branch',
+            'git-commit',
+            'git-diff',
+            'git-log',
+            'git-push',
+            'list-directory',
+            'read-file',
+            'run-command',
+            'search-codebase',
+            'write-file',
+        ]);
+    });
+    it('does not register artifact tools when no store is provided', () => {
+        const registry = createToolRegistry();
+        expect(registry['read-artifact']).toBeUndefined();
+        expect(registry['write-artifact']).toBeUndefined();
+    });
+    it('registers artifact tools when an ArtifactStore is provided', () => {
+        const store = {
+            read: vi.fn(),
+            write: vi.fn(),
+            list: vi.fn(),
+            history: vi.fn(),
+        };
+        const registry = createToolRegistry({ artifactStore: store });
+        expect(registry['read-artifact']).toBeDefined();
+        expect(registry['write-artifact']).toBeDefined();
+        expect(registry['read-artifact'].name).toBe('read-artifact');
+        expect(registry['write-artifact'].name).toBe('write-artifact');
+    });
+    it('each tool has name, description, parameters, and execute', () => {
+        const registry = createToolRegistry();
+        for (const [name, tool] of Object.entries(registry)) {
+            expect(tool.name).toBe(name);
+            expect(tool.description).toBeTruthy();
+            expect(tool.parameters).toBeDefined();
+            expect(typeof tool.execute).toBe('function');
+        }
+    });
+});
+describe('artifact tool: read-artifact', () => {
+    it('returns artifact content when found', async () => {
+        const store = {
+            read: vi.fn().mockResolvedValue({
+                path: 'work/CREW-03/requirements.md',
+                content: '# Requirements',
+                frontmatter: { status: 'approved' },
+            }),
+            write: vi.fn(),
+            list: vi.fn(),
+            history: vi.fn(),
+        };
+        const registry = createToolRegistry({ artifactStore: store });
+        const result = await registry['read-artifact'].execute({ type: 'requirements', scope: { epic: 'CREW-03' } }, mockContext);
+        expect(result).toEqual({
+            found: true,
+            path: 'work/CREW-03/requirements.md',
+            content: '# Requirements',
+            frontmatter: { status: 'approved' },
+        });
+        expect(store.read).toHaveBeenCalledWith('requirements', { epic: 'CREW-03' });
+    });
+    it('returns found: false when artifact does not exist', async () => {
+        const store = {
+            read: vi.fn().mockResolvedValue(null),
+            write: vi.fn(),
+            list: vi.fn(),
+            history: vi.fn(),
+        };
+        const registry = createToolRegistry({ artifactStore: store });
+        const result = await registry['read-artifact'].execute({ type: 'design', scope: { epic: 'CREW-99' } }, mockContext);
+        expect(result).toEqual({
+            found: false,
+            type: 'design',
+            scope: { epic: 'CREW-99' },
+        });
+    });
+});
+describe('artifact tool: write-artifact', () => {
+    it('writes content to the artifact store', async () => {
+        const store = {
+            read: vi.fn(),
+            write: vi.fn().mockResolvedValue({ path: 'work/CREW-03/review.md', bytesWritten: 128 }),
+            list: vi.fn(),
+            history: vi.fn(),
+        };
+        const registry = createToolRegistry({ artifactStore: store });
+        const result = await registry['write-artifact'].execute({
+            type: 'review',
+            scope: { epic: 'CREW-03' },
+            content: '# Review\n\nLooks good.',
+            frontmatter: { status: 'published', author: 'engineer' },
+        }, mockContext);
+        expect(result).toEqual({ path: 'work/CREW-03/review.md', bytesWritten: 128 });
+        expect(store.write).toHaveBeenCalledWith('review', { epic: 'CREW-03' }, '# Review\n\nLooks good.', { status: 'published', author: 'engineer' });
+    });
+    it('defaults frontmatter to empty object when not provided', async () => {
+        const store = {
+            read: vi.fn(),
+            write: vi.fn().mockResolvedValue({ path: 'work/CREW-03/review.md', bytesWritten: 64 }),
+            list: vi.fn(),
+            history: vi.fn(),
+        };
+        const registry = createToolRegistry({ artifactStore: store });
+        await registry['write-artifact'].execute({ type: 'review', scope: { epic: 'CREW-03' }, content: 'content' }, mockContext);
+        expect(store.write).toHaveBeenCalledWith('review', { epic: 'CREW-03' }, 'content', {});
+    });
+});

package/dist/tools/tool-groups.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tool group definitions that map persona-spec-level logical names
+ * to individual tool names in the CrewTool registry.
+ *
+ * Persona specs use category names (e.g. "code", "git-operations")
+ * for readability. The registry uses granular names (e.g. "write-file",
+ * "git-branch"). This module bridges the two.
+ *
+ * Code and git groups are split into read/write halves so that
+ * read-only personas (e.g. Reviewer) can deny writes without
+ * losing read access.
+ */
+export declare const TOOL_GROUPS: Readonly<Record<string, readonly string[]>>;
+/**
+ * Expand a set of tool names, replacing any group names with their
+ * constituent individual tool names. Names that are not groups pass
+ * through unchanged.
+ */
+export declare function expandToolNames(names: ReadonlySet<string> | readonly string[]): Set<string>;
+//# sourceMappingURL=tool-groups.d.ts.map

package/dist/tools/tool-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-groups.d.ts","sourceRoot":"","sources":["../../src/tools/tool-groups.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAWnE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAW3F"}

package/dist/tools/tool-groups.js

@@ -0,0 +1,48 @@
+/**
+ * Tool group definitions that map persona-spec-level logical names
+ * to individual tool names in the CrewTool registry.
+ *
+ * Persona specs use category names (e.g. "code", "git-operations")
+ * for readability. The registry uses granular names (e.g. "write-file",
+ * "git-branch"). This module bridges the two.
+ *
+ * Code and git groups are split into read/write halves so that
+ * read-only personas (e.g. Reviewer) can deny writes without
+ * losing read access.
+ */
+const CODE_READ = ['read-file', 'list-directory', 'search-codebase'];
+const CODE_WRITE = ['write-file'];
+const GIT_READ = ['git-diff', 'git-log'];
+const GIT_WRITE = ['git-branch', 'git-commit', 'git-push', 'create-pr'];
+const GIT_ALL = [...GIT_READ, ...GIT_WRITE];
+export const TOOL_GROUPS = {
+    'read-code': CODE_READ,
+    'write-code': CODE_WRITE,
+    code: [...CODE_READ, ...CODE_WRITE],
+    'git-read': GIT_READ,
+    'git-write': GIT_WRITE,
+    'git-operations': GIT_ALL,
+    git: GIT_ALL,
+    shell: ['run-command'],
+    'read-artifact': ['read-artifact'],
+    'write-artifact': ['write-artifact'],
+};
+/**
+ * Expand a set of tool names, replacing any group names with their
+ * constituent individual tool names. Names that are not groups pass
+ * through unchanged.
+ */
+export function expandToolNames(names) {
+    const expanded = new Set();
+    for (const name of names) {
+        const group = TOOL_GROUPS[name];
+        if (group) {
+            for (const tool of group)
+                expanded.add(tool);
+        }
+        else {
+            expanded.add(name);
+        }
+    }
+    return expanded;
+}

package/dist/tools/tool-groups.test.d.ts

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

package/dist/tools/tool-groups.test.d.ts.map

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

package/dist/tools/tool-groups.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest';
+import { expandToolNames, TOOL_GROUPS } from './tool-groups.js';
+describe('tool-groups', () => {
+    describe('TOOL_GROUPS', () => {
+        it('defines read-code group with read-only code I/O tools', () => {
+            expect(TOOL_GROUPS['read-code']).toEqual(expect.arrayContaining(['read-file', 'list-directory', 'search-codebase']));
+            expect(TOOL_GROUPS['read-code']).not.toContain('write-file');
+        });
+        it('defines write-code group with write-file only', () => {
+            expect(TOOL_GROUPS['write-code']).toEqual(['write-file']);
+        });
+        it('defines code group as union of read-code and write-code', () => {
+            expect(TOOL_GROUPS['code']).toEqual(expect.arrayContaining(['read-file', 'write-file', 'list-directory', 'search-codebase']));
+        });
+        it('defines git-read group with read-only git tools', () => {
+            expect(TOOL_GROUPS['git-read']).toEqual(expect.arrayContaining(['git-diff', 'git-log']));
+            expect(TOOL_GROUPS['git-read']).not.toContain('git-branch');
+            expect(TOOL_GROUPS['git-read']).not.toContain('git-commit');
+        });
+        it('defines git-write group with mutating git tools', () => {
+            expect(TOOL_GROUPS['git-write']).toEqual(expect.arrayContaining(['git-branch', 'git-commit', 'git-push', 'create-pr']));
+            expect(TOOL_GROUPS['git-write']).not.toContain('git-diff');
+            expect(TOOL_GROUPS['git-write']).not.toContain('git-log');
+        });
+        it('defines git-operations as union of git-read and git-write', () => {
+            expect(TOOL_GROUPS['git-operations']).toEqual(expect.arrayContaining([
+                'git-branch',
+                'git-commit',
+                'git-push',
+                'git-diff',
+                'git-log',
+                'create-pr',
+            ]));
+        });
+        it('defines git as an alias for git-operations', () => {
+            expect(TOOL_GROUPS['git']).toEqual(TOOL_GROUPS['git-operations']);
+        });
+        it('defines shell group mapping to run-command', () => {
+            expect(TOOL_GROUPS['shell']).toEqual(['run-command']);
+        });
+    });
+    describe('expandToolNames', () => {
+        it('expands read-code to read-only code tools', () => {
+            const result = expandToolNames(new Set(['read-code']));
+            expect(result).toEqual(new Set(['read-file', 'list-directory', 'search-codebase']));
+        });
+        it('expands write-code to write-file only', () => {
+            const result = expandToolNames(new Set(['write-code']));
+            expect(result).toEqual(new Set(['write-file']));
+        });
+        it('expands code to the full code I/O set', () => {
+            const result = expandToolNames(new Set(['code']));
+            expect(result).toEqual(new Set(['read-file', 'write-file', 'list-directory', 'search-codebase']));
+        });
+        it('expands git-read to read-only git tools', () => {
+            const result = expandToolNames(new Set(['git-read']));
+            expect(result).toEqual(new Set(['git-diff', 'git-log']));
+        });
+        it('expands git-write to mutating git tools', () => {
+            const result = expandToolNames(new Set(['git-write']));
+            expect(result).toEqual(new Set(['git-branch', 'git-commit', 'git-push', 'create-pr']));
+        });
+        it('passes through names that are not groups', () => {
+            const result = expandToolNames(new Set(['read-file', 'custom-tool']));
+            expect(result).toEqual(new Set(['read-file', 'custom-tool']));
+        });
+        it('expands multiple groups and deduplicates', () => {
+            const result = expandToolNames(new Set(['code', 'git', 'shell']));
+            expect(result).toContain('write-file');
+            expect(result).toContain('read-file');
+            expect(result).toContain('git-branch');
+            expect(result).toContain('git-diff');
+            expect(result).toContain('run-command');
+        });
+        it('handles mix of group names and individual names', () => {
+            const result = expandToolNames(new Set(['shell', 'read-file']));
+            expect(result).toEqual(new Set(['run-command', 'read-file']));
+        });
+        it('accepts an array as input', () => {
+            const result = expandToolNames(['code', 'shell']);
+            expect(result).toContain('write-file');
+            expect(result).toContain('run-command');
+        });
+        it('returns empty set for empty input', () => {
+            const result = expandToolNames(new Set());
+            expect(result.size).toBe(0);
+        });
+        it('expands the Engineer implementer sub-agent tools correctly', () => {
+            const result = expandToolNames(['code', 'git', 'shell']);
+            expect(result).toEqual(new Set([
+                'read-file',
+                'write-file',
+                'list-directory',
+                'search-codebase',
+                'git-branch',
+                'git-commit',
+                'git-push',
+                'git-diff',
+                'git-log',
+                'create-pr',
+                'run-command',
+            ]));
+        });
+        it('expands Reviewer permitted tools without write access', () => {
+            const permitted = expandToolNames([
+                'read-artifact',
+                'write-artifact',
+                'read-code',
+                'git-read',
+                'shell',
+            ]);
+            const denied = expandToolNames(['write-code', 'git-write']);
+            expect(permitted).toContain('read-file');
+            expect(permitted).toContain('git-diff');
+            expect(permitted).toContain('run-command');
+            expect(permitted).not.toContain('write-file');
+            expect(permitted).not.toContain('git-branch');
+            expect(denied).toContain('write-file');
+            expect(denied).toContain('git-branch');
+            expect(denied).not.toContain('read-file');
+            expect(denied).not.toContain('git-diff');
+            for (const tool of denied) {
+                expect(permitted.has(tool)).toBe(false);
+            }
+        });
+    });
+});

package/dist/types/artifact-store.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Abstract artifact store interface.
+ *
+ * Provides CRUD operations for delivery artifacts (requirements, designs,
+ * reviews, etc.) backed by an adapter. The filesystem adapter is the
+ * Phase 1 implementation; future adapters (Linear, Jira, GitHub) implement
+ * the same contract. See ADR-0011.
+ */
+export interface ArtifactRecord {
+    path: string;
+    content: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface ArtifactVersion {
+    commitSha: string;
+    timestamp: string;
+    path: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface ArtifactListFilter {
+    status?: string;
+}
+export interface ArtifactWriteResult {
+    path: string;
+    bytesWritten: number;
+}
+export interface ArtifactStore {
+    read(artifactType: string, scope: Record<string, string>): Promise<ArtifactRecord | null>;
+    write(artifactType: string, scope: Record<string, string>, content: string, frontmatter: Record<string, unknown>): Promise<ArtifactWriteResult>;
+    list(artifactType: string, filter?: ArtifactListFilter): Promise<ArtifactRecord[]>;
+    history(artifactType: string, scope: Record<string, string>): Promise<ArtifactVersion[]>;
+}
+//# sourceMappingURL=artifact-store.d.ts.map

package/dist/types/artifact-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-store.d.ts","sourceRoot":"","sources":["../../src/types/artifact-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAE1F,KAAK,CACH,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEhC,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAEnF,OAAO,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;CAC1F"}