@dleangen/cage-issues 0.0.1 → 0.1.0

package/dist/mcp/tools/issues.js

@@ -0,0 +1,313 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerIssueTools = registerIssueTools;
+const zod_1 = require("zod");
+const fsHelper = __importStar(require("../../fs"));
+const maturity_1 = require("../../maturity");
+const track_1 = require("../../track");
+function withDerived(issue, root) {
+    const config = fsHelper.readConfig(root);
+    return {
+        ...issue,
+        maturity: (0, maturity_1.calculateMaturity)(issue),
+        track: (0, track_1.deriveTrack)(issue.affects, config),
+    };
+}
+function wordSet(text) {
+    return new Set(text
+        .toLowerCase()
+        .split(/\W+/)
+        .filter((w) => w.length > 3));
+}
+function similarityScore(a, b) {
+    const setA = wordSet(a);
+    const setB = wordSet(b);
+    const intersection = [...setA].filter((w) => setB.has(w)).length;
+    const union = new Set([...setA, ...setB]).size;
+    return union === 0 ? 0 : intersection / union;
+}
+function findSimilar(root, title, description, topicId) {
+    const topicIds = topicId ? [topicId] : fsHelper.listTopicIds(root);
+    const query = title + ' ' + description;
+    const results = [];
+    for (const tid of topicIds) {
+        for (const id of fsHelper.listIssueIds(root, tid)) {
+            const issue = fsHelper.readIssue(root, id);
+            const candidate = issue.title + ' ' + issue.description;
+            const score = similarityScore(query, candidate);
+            if (score > 0.2) {
+                results.push({
+                    confidence: score > 0.6 ? 'high' : score > 0.35 ? 'medium' : 'low',
+                    id: issue.id,
+                    score,
+                    title: issue.title,
+                });
+            }
+        }
+    }
+    return results.sort((a, b) => b.score - a.score);
+}
+function registerIssueTools(server, root) {
+    // create_issue
+    server.tool('create_issue', 'Create a new issue. Automatically checks for duplicates before creating.', {
+        topic: zod_1.z.string().describe('Topic ID (must be active)'),
+        title: zod_1.z.string().describe('Short description'),
+        description: zod_1.z.string().describe('Full prose description'),
+        priority: zod_1.z.enum(['p1', 'p2', 'p3', 'p4']).optional(),
+        what_to_resolve: zod_1.z.string().optional(),
+        focus: zod_1.z.string().optional(),
+        facet: zod_1.z.string().optional(),
+        impact: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional(),
+        impact_note: zod_1.z.string().optional(),
+        classification: zod_1.z.enum(['standard', 'mechanical-refactor', 'architectural']).optional(),
+        base_branch: zod_1.z.string().optional(),
+        related: zod_1.z.array(zod_1.z.string()).optional(),
+        dependencies: zod_1.z.array(zod_1.z.string()).optional(),
+    }, async (input) => {
+        if (!fsHelper.topicExists(root, input.topic)) {
+            return { content: [{ type: 'text', text: `Error: topic "${input.topic}" not found` }] };
+        }
+        const topic = fsHelper.readTopic(root, input.topic);
+        if (topic.status === 'closed') {
+            return { content: [{ type: 'text', text: `Error: topic "${input.topic}" is closed` }] };
+        }
+        const duplicates = findSimilar(root, input.title, input.description, input.topic);
+        const warnings = duplicates.length > 0
+            ? `Warning: possible duplicates found:\n${duplicates.map((d) => `  ${d.id}: ${d.title} (confidence: ${d.confidence})`).join('\n')}\n\n`
+            : '';
+        const id = fsHelper.nextIssueId(root, input.topic);
+        const now = new Date().toISOString();
+        const issue = {
+            id,
+            date: now.split('T')[0],
+            title: input.title,
+            description: input.description,
+            status: 'open',
+            status_history: [{ status: 'open', timestamp: now, by: 'system' }],
+            ...(input.priority && { priority: input.priority }),
+            ...(input.what_to_resolve && { what_to_resolve: input.what_to_resolve }),
+            ...(input.focus && { focus: input.focus }),
+            ...(input.facet && { facet: input.facet }),
+            ...(input.impact && { impact: input.impact }),
+            ...(input.impact_note && { impact_note: input.impact_note }),
+            ...(input.classification && { classification: input.classification }),
+            ...(input.base_branch && { base_branch: input.base_branch }),
+            ...(input.related && { related: input.related }),
+            ...(input.dependencies && { dependencies: input.dependencies }),
+        };
+        fsHelper.writeIssue(root, issue);
+        const result = withDerived(issue, root);
+        return {
+            content: [{ type: 'text', text: warnings + JSON.stringify(result, null, 2) }],
+        };
+    });
+    // get_issue
+    server.tool('get_issue', 'Get a single issue by ID, including derived maturity and track.', { id: zod_1.z.string().describe('Issue ID, e.g. SHELL-2026-0001') }, async ({ id }) => {
+        if (!fsHelper.issueExists(root, id)) {
+            return { content: [{ type: 'text', text: `Error: issue "${id}" not found` }] };
+        }
+        const issue = fsHelper.readIssue(root, id);
+        return { content: [{ type: 'text', text: JSON.stringify(withDerived(issue, root), null, 2) }] };
+    });
+    // update_issue
+    server.tool('update_issue', 'Partially update an issue. Only provided fields are changed. Status changes append to status_history. Task updates merge by task id.', {
+        id: zod_1.z.string().describe('Issue ID'),
+        title: zod_1.z.string().optional(),
+        description: zod_1.z.string().optional(),
+        status: zod_1.z.enum(['open', 'in_progress', 'resolved', 'cancelled']).optional(),
+        priority: zod_1.z.enum(['p1', 'p2', 'p3', 'p4']).optional(),
+        what_to_resolve: zod_1.z.string().optional(),
+        tasks: zod_1.z
+            .array(zod_1.z.object({
+            id: zod_1.z.string(),
+            description: zod_1.z.string().optional(),
+            status: zod_1.z.enum(['open', 'in_progress', 'done']).optional(),
+            priority: zod_1.z.enum(['must-have', 'nice-to-have', 'optional']).optional(),
+        }))
+            .optional()
+            .describe('Task updates — merged by id, not replaced'),
+        affects: zod_1.z.array(zod_1.z.string()).optional(),
+        focus: zod_1.z.string().optional(),
+        facet: zod_1.z.string().optional(),
+        impact: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional(),
+        impact_note: zod_1.z.string().optional(),
+        classification: zod_1.z.enum(['standard', 'mechanical-refactor', 'architectural']).optional(),
+        base_branch: zod_1.z.string().optional(),
+        related: zod_1.z.array(zod_1.z.string()).optional(),
+        dependencies: zod_1.z.array(zod_1.z.string()).optional(),
+        pull_request: zod_1.z.string().optional(),
+    }, async (input) => {
+        if (!fsHelper.issueExists(root, input.id)) {
+            return { content: [{ type: 'text', text: `Error: issue "${input.id}" not found` }] };
+        }
+        const issue = fsHelper.readIssue(root, input.id);
+        // Apply scalar field updates
+        const scalarFields = [
+            'title', 'description', 'priority', 'what_to_resolve', 'affects',
+            'focus', 'facet', 'impact', 'impact_note', 'classification',
+            'base_branch', 'related', 'dependencies', 'pull_request',
+        ];
+        for (const field of scalarFields) {
+            if (input[field] !== undefined) {
+                issue[field] = input[field];
+            }
+        }
+        // Status change: append history entry
+        if (input.status && input.status !== issue.status) {
+            issue.status = input.status;
+            issue.status_history = [
+                ...(issue.status_history ?? []),
+                { status: input.status, timestamp: new Date().toISOString(), by: 'agent' },
+            ];
+        }
+        // Task updates: merge by id
+        if (input.tasks) {
+            const existing = new Map((issue.tasks ?? []).map((t) => [t.id, t]));
+            for (const update of input.tasks) {
+                const task = existing.get(update.id);
+                if (task) {
+                    Object.assign(task, Object.fromEntries(Object.entries(update).filter(([, v]) => v !== undefined)));
+                }
+                else {
+                    // New task — require all fields
+                    existing.set(update.id, update);
+                }
+            }
+            issue.tasks = [...existing.values()];
+        }
+        fsHelper.writeIssue(root, issue);
+        return { content: [{ type: 'text', text: JSON.stringify(withDerived(issue, root), null, 2) }] };
+    });
+    // list_issues
+    server.tool('list_issues', 'List issues with optional filters.', {
+        topic: zod_1.z.string().optional().describe('Filter by topic ID'),
+        status: zod_1.z.enum(['open', 'in_progress', 'resolved', 'cancelled']).optional(),
+        priority: zod_1.z.enum(['p1', 'p2', 'p3', 'p4']).optional(),
+        maturity: zod_1.z.enum(['draft', 'defined', 'ready', 'verified']).optional(),
+        track: zod_1.z.string().optional(),
+        date_from: zod_1.z.string().optional().describe('ISO date, inclusive'),
+        date_to: zod_1.z.string().optional().describe('ISO date, inclusive'),
+    }, async (input) => {
+        const topicIds = input.topic ? [input.topic] : fsHelper.listTopicIds(root);
+        const results = [];
+        for (const tid of topicIds) {
+            for (const id of fsHelper.listIssueIds(root, tid)) {
+                const issue = fsHelper.readIssue(root, id);
+                const derived = withDerived(issue, root);
+                if (input.status && derived.status !== input.status)
+                    continue;
+                if (input.priority && derived.priority !== input.priority)
+                    continue;
+                if (input.maturity && derived.maturity !== input.maturity)
+                    continue;
+                if (input.track && derived.track !== input.track)
+                    continue;
+                if (input.date_from && derived.date < input.date_from)
+                    continue;
+                if (input.date_to && derived.date > input.date_to)
+                    continue;
+                results.push(derived);
+            }
+        }
+        results.sort((a, b) => b.date.localeCompare(a.date));
+        return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+    });
+    // search_issues
+    server.tool('search_issues', 'Free-text search across issue titles and descriptions, ranked by relevance.', {
+        query: zod_1.z.string(),
+        topic: zod_1.z.string().optional().describe('Scope search to a single topic'),
+    }, async ({ query, topic }) => {
+        const topicIds = topic ? [topic] : fsHelper.listTopicIds(root);
+        const results = [];
+        for (const tid of topicIds) {
+            for (const id of fsHelper.listIssueIds(root, tid)) {
+                const issue = fsHelper.readIssue(root, id);
+                const score = similarityScore(query, issue.title + ' ' + issue.description);
+                if (score > 0)
+                    results.push({ issue: withDerived(issue, root), score });
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(results.map((r) => r.issue), null, 2) }],
+        };
+    });
+    // find_duplicates
+    server.tool('find_duplicates', 'Check for existing issues similar to a proposed new one.', {
+        title: zod_1.z.string(),
+        description: zod_1.z.string(),
+        topic: zod_1.z.string().optional().describe('Scope to a single topic'),
+    }, async ({ title, description, topic }) => {
+        const results = findSimilar(root, title, description, topic);
+        return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+    });
+    // validate_issue
+    server.tool('validate_issue', 'Record a validation result. On pass, appends a signoff. On fail, no trace is recorded.', {
+        id: zod_1.z.string().describe('Issue ID'),
+        role: zod_1.z.string().describe('Validating agent role, e.g. Architect, Critic'),
+        result: zod_1.z.enum(['pass', 'fail']),
+        note: zod_1.z.string().describe('What was checked and why it passed or failed'),
+    }, async ({ id, role, result, note }) => {
+        if (!fsHelper.issueExists(root, id)) {
+            return { content: [{ type: 'text', text: `Error: issue "${id}" not found` }] };
+        }
+        const issue = fsHelper.readIssue(root, id);
+        const maturity = (0, maturity_1.calculateMaturity)(issue);
+        if (maturity === 'draft' || maturity === 'defined') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: issue "${id}" is at maturity "${maturity}" — must be Ready or above to validate`,
+                    },
+                ],
+            };
+        }
+        if (result === 'fail') {
+            return {
+                content: [
+                    { type: 'text', text: `Validation failed. No trace recorded. Feedback: ${note}` },
+                ],
+            };
+        }
+        issue.signoffs = [
+            ...(issue.signoffs ?? []),
+            { role, timestamp: new Date().toISOString(), note },
+        ];
+        fsHelper.writeIssue(root, issue);
+        return { content: [{ type: 'text', text: JSON.stringify(withDerived(issue, root), null, 2) }] };
+    });
+}

package/dist/mcp/tools/topics.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTopicTools(server: McpServer, root: string): void;

package/dist/mcp/tools/topics.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTopicTools = registerTopicTools;
+const zod_1 = require("zod");
+const fsHelper = __importStar(require("../../fs"));
+function registerTopicTools(server, root) {
+    // create_topic
+    server.tool('create_topic', 'Create a new topic and its directory structure (topic.yaml, backlog.yaml, issues/).', {
+        id: zod_1.z.string().describe('Topic ID — uppercase, e.g. SHELL'),
+        name: zod_1.z.string().describe('Human-readable name'),
+        description: zod_1.z.string().describe('What this topic covers'),
+        owner: zod_1.z.string().describe('Owner email or name'),
+    }, async ({ id, name, description, owner }) => {
+        const topicId = id.toUpperCase();
+        if (fsHelper.topicExists(root, topicId)) {
+            return { content: [{ type: 'text', text: `Error: topic "${topicId}" already exists` }] };
+        }
+        const topic = { id: topicId, name, description, owner, status: 'active' };
+        fsHelper.writeTopic(root, topic);
+        fsHelper.writeBacklog(root, topicId, { active: [], up_next: [], deferred: [] });
+        // Ensure issues/ dir exists
+        const issuesDirPath = fsHelper.issueDir(root, topicId);
+        const { mkdirSync } = await Promise.resolve().then(() => __importStar(require('node:fs')));
+        mkdirSync(issuesDirPath, { recursive: true });
+        return { content: [{ type: 'text', text: JSON.stringify(topic, null, 2) }] };
+    });
+    // list_topics
+    server.tool('list_topics', 'List all topics with their status.', {}, async () => {
+        const topicIds = fsHelper.listTopicIds(root);
+        const topics = topicIds.map((id) => fsHelper.readTopic(root, id));
+        return { content: [{ type: 'text', text: JSON.stringify(topics, null, 2) }] };
+    });
+    // close_topic
+    server.tool('close_topic', 'Permanently close a topic. No new issues may be filed. Existing issues are preserved.', { id: zod_1.z.string().describe('Topic ID') }, async ({ id }) => {
+        const topicId = id.toUpperCase();
+        if (!fsHelper.topicExists(root, topicId)) {
+            return { content: [{ type: 'text', text: `Error: topic "${topicId}" not found` }] };
+        }
+        const topic = fsHelper.readTopic(root, topicId);
+        if (topic.status === 'closed') {
+            return { content: [{ type: 'text', text: `Error: topic "${topicId}" is already closed` }] };
+        }
+        topic.status = 'closed';
+        fsHelper.writeTopic(root, topic);
+        return { content: [{ type: 'text', text: JSON.stringify(topic, null, 2) }] };
+    });
+}

package/dist/mcp/tools/tracks.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTrackTools(server: McpServer, root: string): void;

package/dist/mcp/tools/tracks.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTrackTools = registerTrackTools;
+const zod_1 = require("zod");
+const fsHelper = __importStar(require("../../fs"));
+function registerTrackTools(server, root) {
+    // create_track
+    server.tool('create_track', 'Add a project-specific track definition to config.yaml.', {
+        id: zod_1.z.string().describe('Track ID, e.g. frontend'),
+        name: zod_1.z.string().describe('Human-readable name'),
+        affects_patterns: zod_1.z
+            .array(zod_1.z.string())
+            .describe('Path prefixes that map to this track, e.g. ["src/", "components/"]'),
+    }, async ({ id, name, affects_patterns }) => {
+        const config = fsHelper.readConfig(root);
+        if (config.tracks.some((t) => t.id === id)) {
+            return { content: [{ type: 'text', text: `Error: track "${id}" already exists` }] };
+        }
+        const track = { id, name, affects_patterns };
+        config.tracks.push(track);
+        fsHelper.writeYaml(fsHelper.configPath(root), config);
+        return { content: [{ type: 'text', text: JSON.stringify(track, null, 2) }] };
+    });
+    // list_tracks
+    server.tool('list_tracks', 'List all track definitions — both built-in generic tracks and project-specific tracks from config.yaml.', {}, async () => {
+        const GENERIC_TRACKS = [
+            { id: 'data', name: 'Data', affects_patterns: ['data/'] },
+            { id: 'docs', name: 'Docs', affects_patterns: ['README.md', 'docs/'] },
+            { id: 'meta', name: 'Meta', affects_patterns: ['agents/', 'skills/', 'adr/', 'retrospectives/'] },
+            { id: 'issues', name: 'Issues', affects_patterns: ['issues/', 'topics/'] },
+        ];
+        const config = fsHelper.readConfig(root);
+        const result = {
+            generic: GENERIC_TRACKS,
+            project: config.tracks,
+        };
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    // update_track
+    server.tool('update_track', 'Update a project-specific track definition in config.yaml.', {
+        id: zod_1.z.string().describe('Track ID to update'),
+        name: zod_1.z.string().optional(),
+        affects_patterns: zod_1.z.array(zod_1.z.string()).optional(),
+    }, async ({ id, name, affects_patterns }) => {
+        const config = fsHelper.readConfig(root);
+        const track = config.tracks.find((t) => t.id === id);
+        if (!track) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: track "${id}" not found — only project-specific tracks can be updated`,
+                    },
+                ],
+            };
+        }
+        if (name !== undefined)
+            track.name = name;
+        if (affects_patterns !== undefined)
+            track.affects_patterns = affects_patterns;
+        fsHelper.writeYaml(fsHelper.configPath(root), config);
+        return { content: [{ type: 'text', text: JSON.stringify(track, null, 2) }] };
+    });
+    // close_track
+    server.tool('close_track', 'Deactivate a project-specific track. Existing issues retain their derived track value.', { id: zod_1.z.string().describe('Track ID to deactivate') }, async ({ id }) => {
+        const config = fsHelper.readConfig(root);
+        const track = config.tracks.find((t) => t.id === id);
+        if (!track) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: track "${id}" not found — only project-specific tracks can be closed`,
+                    },
+                ],
+            };
+        }
+        if (track.active === false) {
+            return { content: [{ type: 'text', text: `Error: track "${id}" is already inactive` }] };
+        }
+        track.active = false;
+        fsHelper.writeYaml(fsHelper.configPath(root), config);
+        return { content: [{ type: 'text', text: JSON.stringify(track, null, 2) }] };
+    });
+}

package/dist/schema.d.ts

@@ -0,0 +1,78 @@
+export type IssueStatus = 'open' | 'in_progress' | 'resolved' | 'cancelled';
+export type IssuePriority = 'p1' | 'p2' | 'p3' | 'p4';
+export type IssueImpact = 'low' | 'medium' | 'high' | 'critical';
+export type IssueMaturity = 'draft' | 'defined' | 'ready' | 'verified';
+export type IssueClassification = 'standard' | 'mechanical-refactor' | 'architectural';
+export type TaskStatus = 'open' | 'in_progress' | 'done';
+export type TaskPriority = 'must-have' | 'nice-to-have' | 'optional';
+export type TopicStatus = 'active' | 'closed';
+export interface Task {
+    id: string;
+    description: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+}
+export interface Signoff {
+    role: string;
+    timestamp: string;
+    note: string;
+}
+export interface StatusHistoryEntry {
+    status: IssueStatus;
+    timestamp: string;
+    by: string;
+}
+export interface Issue {
+    id: string;
+    date: string;
+    title: string;
+    description: string;
+    status: IssueStatus;
+    status_history: StatusHistoryEntry[];
+    priority?: IssuePriority;
+    what_to_resolve?: string;
+    tasks?: Task[];
+    affects?: string[];
+    signoffs?: Signoff[];
+    focus?: string;
+    facet?: string;
+    impact?: IssueImpact;
+    impact_note?: string;
+    classification?: IssueClassification;
+    base_branch?: string;
+    related?: string[];
+    dependencies?: string[];
+    pull_request?: string;
+}
+export interface IssueWithDerived extends Issue {
+    maturity: IssueMaturity;
+    track: string | null;
+}
+export interface Topic {
+    id: string;
+    name: string;
+    description: string;
+    owner: string;
+    status: TopicStatus;
+}
+export interface BacklogEntry {
+    id: string;
+    title: string;
+    rationale: string;
+}
+export interface Backlog {
+    active: BacklogEntry[];
+    up_next: BacklogEntry[];
+    deferred: BacklogEntry[];
+}
+export interface TrackDefinition {
+    id: string;
+    name: string;
+    affects_patterns: string[];
+    active?: boolean;
+}
+export interface Config {
+    priority_labels: Record<IssuePriority, string>;
+    impact_labels: Record<IssueImpact, string>;
+    tracks: TrackDefinition[];
+}

package/dist/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+// Core enumerations
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/track.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from './schema';
+export declare function deriveTrack(affects: string[] | undefined, config: Config): string | null;

package/dist/track.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveTrack = deriveTrack;
+const GENERIC_TRACKS = [
+    { id: 'data', affects_patterns: ['data/'] },
+    { id: 'docs', affects_patterns: ['README.md', 'docs/'] },
+    { id: 'meta', affects_patterns: ['agents/', 'skills/', 'adr/', 'retrospectives/'] },
+    { id: 'issues', affects_patterns: ['issues/', 'topics/'] },
+];
+function deriveTrack(affects, config) {
+    if (!affects || affects.length === 0)
+        return null;
+    const primary = affects[0];
+    // Project-specific tracks take priority over generic tracks
+    for (const track of config.tracks) {
+        if (track.active === false)
+            continue;
+        for (const pattern of track.affects_patterns) {
+            if (primary.startsWith(pattern) || primary === pattern)
+                return track.id;
+        }
+    }
+    for (const track of GENERIC_TRACKS) {
+        for (const pattern of track.affects_patterns) {
+            if (primary.startsWith(pattern) || primary === pattern)
+                return track.id;
+        }
+    }
+    return null;
+}