@mono-labs/tracker 0.1.269

package/dist/manager/notation-manager.js

@@ -0,0 +1,137 @@
+"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.NotationManager = void 0;
+const path = __importStar(require("path"));
+const storage_1 = require("../storage");
+const utils_1 = require("../utils");
+const relationship_manager_1 = require("./relationship-manager");
+const validator_1 = require("./validator");
+const stats_1 = require("./stats");
+class NotationManager {
+    storage;
+    notations = [];
+    config;
+    constructor(config) {
+        this.config = config;
+        const storagePath = path.isAbsolute(config.storagePath)
+            ? config.storagePath
+            : path.join(config.rootDir, config.storagePath);
+        this.storage = new storage_1.JsonlStorage(storagePath);
+    }
+    async load() {
+        this.notations = await this.storage.readAll();
+    }
+    async save() {
+        await this.storage.writeAll(this.notations);
+    }
+    getAll() {
+        return [...this.notations];
+    }
+    setAll(notations) {
+        this.notations = [...notations];
+    }
+    getById(id) {
+        return this.notations.find((n) => n.id === id);
+    }
+    query(q) {
+        return this.notations.filter((n) => {
+            if (q.type) {
+                const types = Array.isArray(q.type) ? q.type : [q.type];
+                if (!types.includes(n.type))
+                    return false;
+            }
+            if (q.tags && q.tags.length > 0) {
+                if (!q.tags.some((t) => n.tags.includes(t)))
+                    return false;
+            }
+            if (q.priority) {
+                const priorities = Array.isArray(q.priority) ? q.priority : [q.priority];
+                if (!n.priority || !priorities.includes(n.priority))
+                    return false;
+            }
+            if (q.status) {
+                const statuses = Array.isArray(q.status) ? q.status : [q.status];
+                if (!statuses.includes(n.status))
+                    return false;
+            }
+            if (q.file) {
+                if (!n.location.file.includes(q.file))
+                    return false;
+            }
+            if (q.assignee) {
+                if (n.assignee !== q.assignee)
+                    return false;
+            }
+            if (q.overdue === true) {
+                if (!n.dueDate || !(0, utils_1.isOverdue)(n.dueDate) || n.status === 'resolved')
+                    return false;
+            }
+            if (q.blocked === true) {
+                if (!(0, relationship_manager_1.isBlocked)(n, this.notations))
+                    return false;
+            }
+            if (q.search) {
+                const lower = q.search.toLowerCase();
+                const searchable = `${n.description} ${n.body.join(' ')} ${n.tags.join(' ')}`.toLowerCase();
+                if (!searchable.includes(lower))
+                    return false;
+            }
+            if (q.dueBefore) {
+                if (!n.dueDate || n.dueDate > q.dueBefore)
+                    return false;
+            }
+            if (q.dueAfter) {
+                if (!n.dueDate || n.dueDate < q.dueAfter)
+                    return false;
+            }
+            return true;
+        });
+    }
+    update(id, updates) {
+        const idx = this.notations.findIndex((n) => n.id === id);
+        if (idx === -1)
+            return false;
+        this.notations[idx] = { ...this.notations[idx], ...updates };
+        return true;
+    }
+    validate() {
+        return (0, validator_1.validateAll)(this.notations);
+    }
+    stats() {
+        return (0, stats_1.computeStats)(this.notations);
+    }
+}
+exports.NotationManager = NotationManager;

package/dist/manager/notation-manager.test.d.ts

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

package/dist/manager/notation-manager.test.d.ts.map

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

package/dist/manager/notation-manager.test.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const notation_manager_1 = require("./notation-manager");
+const stats_1 = require("./stats");
+const relationship_manager_1 = require("./relationship-manager");
+const notation_updater_1 = require("./notation-updater");
+const validator_1 = require("./validator");
+function makeNotation(overrides = {}) {
+    return {
+        id: 'N-test001',
+        type: 'TODO',
+        description: 'Test notation',
+        body: [],
+        codeContext: [],
+        location: { file: 'test.ts', line: 1, column: 1 },
+        status: 'open',
+        tags: [],
+        actions: [],
+        relationships: [],
+        rawBlock: '// TODO: Test',
+        scannedAt: '2026-01-01T00:00:00.000Z',
+        ...overrides,
+    };
+}
+const testConfig = {
+    rootDir: '/tmp/test-project',
+    include: ['**/*.ts'],
+    exclude: ['**/node_modules/**'],
+    markers: ['TODO', 'FIXME', 'BUG', 'HACK', 'NOTE', 'OPTIMIZE', 'SECURITY'],
+    storagePath: '/tmp/test-tracker/notations.jsonl',
+    idPrefix: 'N',
+};
+(0, vitest_1.describe)('NotationManager', () => {
+    let manager;
+    (0, vitest_1.beforeEach)(() => {
+        manager = new notation_manager_1.NotationManager(testConfig);
+    });
+    (0, vitest_1.it)('starts empty', () => {
+        (0, vitest_1.expect)(manager.getAll()).toEqual([]);
+    });
+    (0, vitest_1.it)('sets and gets notations', () => {
+        const notations = [makeNotation({ id: 'N-1' }), makeNotation({ id: 'N-2' })];
+        manager.setAll(notations);
+        (0, vitest_1.expect)(manager.getAll()).toHaveLength(2);
+    });
+    (0, vitest_1.it)('gets by id', () => {
+        manager.setAll([makeNotation({ id: 'N-1', description: 'First' })]);
+        (0, vitest_1.expect)(manager.getById('N-1')?.description).toBe('First');
+        (0, vitest_1.expect)(manager.getById('N-999')).toBeUndefined();
+    });
+    (0, vitest_1.it)('updates a notation', () => {
+        manager.setAll([makeNotation({ id: 'N-1' })]);
+        const updated = manager.update('N-1', { description: 'Updated' });
+        (0, vitest_1.expect)(updated).toBe(true);
+        (0, vitest_1.expect)(manager.getById('N-1')?.description).toBe('Updated');
+    });
+    (0, vitest_1.it)('returns false when updating non-existent id', () => {
+        (0, vitest_1.expect)(manager.update('N-999', { description: 'nope' })).toBe(false);
+    });
+    (0, vitest_1.describe)('query', () => {
+        (0, vitest_1.beforeEach)(() => {
+            manager.setAll([
+                makeNotation({ id: 'N-1', type: 'TODO', priority: 'high', tags: ['ui'], assignee: 'Alice', status: 'open' }),
+                makeNotation({ id: 'N-2', type: 'FIXME', priority: 'low', tags: ['api'], assignee: 'Bob', status: 'open' }),
+                makeNotation({ id: 'N-3', type: 'BUG', priority: 'critical', tags: ['ui', 'api'], status: 'resolved' }),
+                makeNotation({ id: 'N-4', type: 'TODO', dueDate: '2020-01-01', status: 'open' }),
+                makeNotation({ id: 'N-5', type: 'TODO', description: 'Search me please', status: 'open' }),
+            ]);
+        });
+        (0, vitest_1.it)('filters by type', () => {
+            (0, vitest_1.expect)(manager.query({ type: 'TODO' })).toHaveLength(3);
+        });
+        (0, vitest_1.it)('filters by multiple types', () => {
+            (0, vitest_1.expect)(manager.query({ type: ['TODO', 'BUG'] })).toHaveLength(4);
+        });
+        (0, vitest_1.it)('filters by tags', () => {
+            (0, vitest_1.expect)(manager.query({ tags: ['ui'] })).toHaveLength(2);
+        });
+        (0, vitest_1.it)('filters by priority', () => {
+            (0, vitest_1.expect)(manager.query({ priority: 'high' })).toHaveLength(1);
+        });
+        (0, vitest_1.it)('filters by status', () => {
+            (0, vitest_1.expect)(manager.query({ status: 'resolved' })).toHaveLength(1);
+        });
+        (0, vitest_1.it)('filters by assignee', () => {
+            (0, vitest_1.expect)(manager.query({ assignee: 'Alice' })).toHaveLength(1);
+        });
+        (0, vitest_1.it)('filters overdue', () => {
+            const overdue = manager.query({ overdue: true });
+            (0, vitest_1.expect)(overdue).toHaveLength(1);
+            (0, vitest_1.expect)(overdue[0].id).toBe('N-4');
+        });
+        (0, vitest_1.it)('filters by search text', () => {
+            const results = manager.query({ search: 'search me' });
+            (0, vitest_1.expect)(results).toHaveLength(1);
+            (0, vitest_1.expect)(results[0].id).toBe('N-5');
+        });
+        (0, vitest_1.it)('filters by file', () => {
+            manager.setAll([
+                makeNotation({ id: 'N-1', location: { file: 'src/app.ts', line: 1, column: 1 } }),
+                makeNotation({ id: 'N-2', location: { file: 'src/utils.ts', line: 1, column: 1 } }),
+            ]);
+            (0, vitest_1.expect)(manager.query({ file: 'app.ts' })).toHaveLength(1);
+        });
+    });
+});
+(0, vitest_1.describe)('computeStats', () => {
+    (0, vitest_1.it)('computes correct totals', () => {
+        const notations = [
+            makeNotation({ id: 'N-1', type: 'TODO', priority: 'high', tags: ['ui'], status: 'open' }),
+            makeNotation({ id: 'N-2', type: 'FIXME', priority: 'low', tags: ['api'], status: 'open', debt: { hours: 4, compounding: 'low' } }),
+            makeNotation({ id: 'N-3', type: 'TODO', status: 'resolved', assignee: 'Alice', debt: { hours: 8, compounding: 'high' } }),
+        ];
+        const stats = (0, stats_1.computeStats)(notations);
+        (0, vitest_1.expect)(stats.total).toBe(3);
+        (0, vitest_1.expect)(stats.byType['TODO']).toBe(2);
+        (0, vitest_1.expect)(stats.byType['FIXME']).toBe(1);
+        (0, vitest_1.expect)(stats.byPriority['high']).toBe(1);
+        (0, vitest_1.expect)(stats.byStatus['open']).toBe(2);
+        (0, vitest_1.expect)(stats.byTag['ui']).toBe(1);
+        (0, vitest_1.expect)(stats.byAssignee['Alice']).toBe(1);
+        (0, vitest_1.expect)(stats.totalDebtHours).toBe(12);
+    });
+});
+(0, vitest_1.describe)('relationship-manager', () => {
+    (0, vitest_1.it)('detects blocked notations', () => {
+        const all = [
+            makeNotation({ id: 'N-1', status: 'open' }),
+            makeNotation({ id: 'N-2', relationships: ['N-1'], status: 'open' }),
+        ];
+        (0, vitest_1.expect)((0, relationship_manager_1.isBlocked)(all[1], all)).toBe(true);
+        (0, vitest_1.expect)((0, relationship_manager_1.isBlocked)(all[0], all)).toBe(false);
+    });
+    (0, vitest_1.it)('not blocked if dependency is resolved', () => {
+        const all = [
+            makeNotation({ id: 'N-1', status: 'resolved' }),
+            makeNotation({ id: 'N-2', relationships: ['N-1'], status: 'open' }),
+        ];
+        (0, vitest_1.expect)((0, relationship_manager_1.isBlocked)(all[1], all)).toBe(false);
+    });
+    (0, vitest_1.it)('detects circular dependencies', () => {
+        const all = [
+            makeNotation({ id: 'N-1', relationships: ['N-2'] }),
+            makeNotation({ id: 'N-2', relationships: ['N-1'] }),
+        ];
+        const cycles = (0, relationship_manager_1.detectCircularDependencies)(all);
+        (0, vitest_1.expect)(cycles.length).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)('returns empty for no cycles', () => {
+        const all = [
+            makeNotation({ id: 'N-1', relationships: [] }),
+            makeNotation({ id: 'N-2', relationships: ['N-1'] }),
+        ];
+        const cycles = (0, relationship_manager_1.detectCircularDependencies)(all);
+        (0, vitest_1.expect)(cycles).toHaveLength(0);
+    });
+});
+(0, vitest_1.describe)('notation-updater', () => {
+    (0, vitest_1.it)('updates status', () => {
+        const n = makeNotation({ status: 'open' });
+        const updated = (0, notation_updater_1.updateStatus)(n, 'resolved');
+        (0, vitest_1.expect)(updated.status).toBe('resolved');
+    });
+    (0, vitest_1.it)('adds tag', () => {
+        const n = makeNotation({ tags: ['a'] });
+        const updated = (0, notation_updater_1.addTag)(n, 'b');
+        (0, vitest_1.expect)(updated.tags).toEqual(['a', 'b']);
+    });
+    (0, vitest_1.it)('does not duplicate tag', () => {
+        const n = makeNotation({ tags: ['a'] });
+        const updated = (0, notation_updater_1.addTag)(n, 'a');
+        (0, vitest_1.expect)(updated.tags).toEqual(['a']);
+    });
+    (0, vitest_1.it)('removes tag', () => {
+        const n = makeNotation({ tags: ['a', 'b'] });
+        const updated = (0, notation_updater_1.removeTag)(n, 'a');
+        (0, vitest_1.expect)(updated.tags).toEqual(['b']);
+    });
+    (0, vitest_1.it)('sets assignee', () => {
+        const n = makeNotation();
+        const updated = (0, notation_updater_1.setAssignee)(n, 'Alice');
+        (0, vitest_1.expect)(updated.assignee).toBe('Alice');
+    });
+});
+(0, vitest_1.describe)('validator', () => {
+    (0, vitest_1.it)('validates a correct notation', () => {
+        const errors = (0, validator_1.validateNotation)(makeNotation());
+        (0, vitest_1.expect)(errors).toHaveLength(0);
+    });
+    (0, vitest_1.it)('catches missing id', () => {
+        const errors = (0, validator_1.validateNotation)(makeNotation({ id: '' }));
+        (0, vitest_1.expect)(errors.some((e) => e.field === 'id')).toBe(true);
+    });
+    (0, vitest_1.it)('catches invalid type', () => {
+        const errors = (0, validator_1.validateNotation)(makeNotation({ type: 'INVALID' }));
+        (0, vitest_1.expect)(errors.some((e) => e.field === 'type')).toBe(true);
+    });
+    (0, vitest_1.it)('catches missing description', () => {
+        const errors = (0, validator_1.validateNotation)(makeNotation({ description: '' }));
+        (0, vitest_1.expect)(errors.some((e) => e.field === 'description')).toBe(true);
+    });
+    (0, vitest_1.it)('detects duplicate ids in validateAll', () => {
+        const errors = (0, validator_1.validateAll)([makeNotation({ id: 'N-1' }), makeNotation({ id: 'N-1' })]);
+        (0, vitest_1.expect)(errors.some((e) => e.message.includes('Duplicate'))).toBe(true);
+    });
+    (0, vitest_1.it)('detects unknown references', () => {
+        const errors = (0, validator_1.validateAll)([makeNotation({ id: 'N-1', relationships: ['N-999'] })]);
+        (0, vitest_1.expect)(errors.some((e) => e.message.includes('Unknown reference'))).toBe(true);
+    });
+});

package/dist/manager/notation-updater.d.ts

@@ -0,0 +1,6 @@
+import type { Notation, Status } from '../types';
+export declare function updateStatus(notation: Notation, status: Status): Notation;
+export declare function addTag(notation: Notation, tag: string): Notation;
+export declare function removeTag(notation: Notation, tag: string): Notation;
+export declare function setAssignee(notation: Notation, assignee: string): Notation;
+//# sourceMappingURL=notation-updater.d.ts.map

package/dist/manager/notation-updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notation-updater.d.ts","sourceRoot":"","sources":["../../src/manager/notation-updater.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEhD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAEzE;AAED,wBAAgB,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAGhE;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAEnE;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAE1E"}

package/dist/manager/notation-updater.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateStatus = updateStatus;
+exports.addTag = addTag;
+exports.removeTag = removeTag;
+exports.setAssignee = setAssignee;
+function updateStatus(notation, status) {
+    return { ...notation, status };
+}
+function addTag(notation, tag) {
+    if (notation.tags.includes(tag))
+        return notation;
+    return { ...notation, tags: [...notation.tags, tag] };
+}
+function removeTag(notation, tag) {
+    return { ...notation, tags: notation.tags.filter((t) => t !== tag) };
+}
+function setAssignee(notation, assignee) {
+    return { ...notation, assignee };
+}

package/dist/manager/relationship-manager.d.ts

@@ -0,0 +1,5 @@
+import type { Notation } from '../types';
+export declare function getBlockers(notation: Notation, allNotations: Notation[]): Notation[];
+export declare function isBlocked(notation: Notation, allNotations: Notation[]): boolean;
+export declare function detectCircularDependencies(notations: Notation[]): string[][];
+//# sourceMappingURL=relationship-manager.d.ts.map

package/dist/manager/relationship-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationship-manager.d.ts","sourceRoot":"","sources":["../../src/manager/relationship-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAGpF;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,CAE/E;AAED,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,MAAM,EAAE,EAAE,CAuC5E"}

package/dist/manager/relationship-manager.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockers = getBlockers;
+exports.isBlocked = isBlocked;
+exports.detectCircularDependencies = detectCircularDependencies;
+function getBlockers(notation, allNotations) {
+    const idSet = new Set(notation.relationships);
+    return allNotations.filter((n) => idSet.has(n.id) && n.status !== 'resolved');
+}
+function isBlocked(notation, allNotations) {
+    return getBlockers(notation, allNotations).length > 0;
+}
+function detectCircularDependencies(notations) {
+    const idToRelationships = new Map();
+    for (const n of notations) {
+        idToRelationships.set(n.id, n.relationships);
+    }
+    const cycles = [];
+    const visited = new Set();
+    const inStack = new Set();
+    function dfs(id, path) {
+        if (inStack.has(id)) {
+            const cycleStart = path.indexOf(id);
+            if (cycleStart !== -1) {
+                cycles.push(path.slice(cycleStart).concat(id));
+            }
+            return;
+        }
+        if (visited.has(id))
+            return;
+        visited.add(id);
+        inStack.add(id);
+        path.push(id);
+        const deps = idToRelationships.get(id) ?? [];
+        for (const dep of deps) {
+            dfs(dep, [...path]);
+        }
+        inStack.delete(id);
+    }
+    for (const n of notations) {
+        if (!visited.has(n.id)) {
+            dfs(n.id, []);
+        }
+    }
+    return cycles;
+}

package/dist/manager/stats.d.ts

@@ -0,0 +1,3 @@
+import type { Notation, NotationStats } from '../types';
+export declare function computeStats(notations: Notation[]): NotationStats;
+//# sourceMappingURL=stats.d.ts.map

package/dist/manager/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../src/manager/stats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAIvD,wBAAgB,YAAY,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,aAAa,CA2CjE"}

package/dist/manager/stats.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeStats = computeStats;
+const utils_1 = require("../utils");
+const relationship_manager_1 = require("./relationship-manager");
+function computeStats(notations) {
+    const stats = {
+        total: notations.length,
+        byType: {},
+        byPriority: {},
+        byStatus: {},
+        byTag: {},
+        byAssignee: {},
+        overdue: 0,
+        blocked: 0,
+        totalDebtHours: 0,
+    };
+    for (const n of notations) {
+        stats.byType[n.type] = (stats.byType[n.type] ?? 0) + 1;
+        stats.byStatus[n.status] = (stats.byStatus[n.status] ?? 0) + 1;
+        if (n.priority) {
+            stats.byPriority[n.priority] = (stats.byPriority[n.priority] ?? 0) + 1;
+        }
+        for (const tag of n.tags) {
+            stats.byTag[tag] = (stats.byTag[tag] ?? 0) + 1;
+        }
+        if (n.assignee) {
+            stats.byAssignee[n.assignee] = (stats.byAssignee[n.assignee] ?? 0) + 1;
+        }
+        if (n.dueDate && (0, utils_1.isOverdue)(n.dueDate) && n.status !== 'resolved') {
+            stats.overdue++;
+        }
+        if ((0, relationship_manager_1.isBlocked)(n, notations)) {
+            stats.blocked++;
+        }
+        if (n.debt) {
+            stats.totalDebtHours += n.debt.hours;
+        }
+    }
+    return stats;
+}

package/dist/manager/validator.d.ts

@@ -0,0 +1,9 @@
+import type { Notation } from '../types';
+export interface ValidationError {
+    notationId: string;
+    field: string;
+    message: string;
+}
+export declare function validateNotation(notation: Notation): ValidationError[];
+export declare function validateAll(notations: Notation[]): ValidationError[];
+//# sourceMappingURL=validator.d.ts.map

package/dist/manager/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/manager/validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAIxC,MAAM,WAAW,eAAe;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;CACf;AAOD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,EAAE,CA0BtE;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,eAAe,EAAE,CA+BpE"}

package/dist/manager/validator.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNotation = validateNotation;
+exports.validateAll = validateAll;
+const enums_1 = require("../types/enums");
+const relationship_manager_1 = require("./relationship-manager");
+const VALID_TYPES = new Set(Object.values(enums_1.MarkerType));
+const VALID_PRIORITIES = new Set(Object.values(enums_1.Priority));
+const VALID_RISKS = new Set(Object.values(enums_1.RiskLevel));
+const VALID_STATUSES = new Set(Object.values(enums_1.Status));
+function validateNotation(notation) {
+    const errors = [];
+    if (!notation.id) {
+        errors.push({ notationId: notation.id, field: 'id', message: 'Missing id' });
+    }
+    if (!VALID_TYPES.has(notation.type)) {
+        errors.push({ notationId: notation.id, field: 'type', message: `Invalid type: ${notation.type}` });
+    }
+    if (!notation.description) {
+        errors.push({ notationId: notation.id, field: 'description', message: 'Missing description' });
+    }
+    if (!notation.location?.file) {
+        errors.push({ notationId: notation.id, field: 'location', message: 'Missing file location' });
+    }
+    if (!VALID_STATUSES.has(notation.status)) {
+        errors.push({ notationId: notation.id, field: 'status', message: `Invalid status: ${notation.status}` });
+    }
+    if (notation.priority && !VALID_PRIORITIES.has(notation.priority)) {
+        errors.push({ notationId: notation.id, field: 'priority', message: `Invalid priority: ${notation.priority}` });
+    }
+    if (notation.risk && !VALID_RISKS.has(notation.risk)) {
+        errors.push({ notationId: notation.id, field: 'risk', message: `Invalid risk: ${notation.risk}` });
+    }
+    return errors;
+}
+function validateAll(notations) {
+    const errors = [];
+    const idSet = new Set();
+    for (const n of notations) {
+        errors.push(...validateNotation(n));
+        if (idSet.has(n.id)) {
+            errors.push({ notationId: n.id, field: 'id', message: `Duplicate id: ${n.id}` });
+        }
+        idSet.add(n.id);
+        // Check reference integrity
+        for (const rel of n.relationships) {
+            if (!notations.some((other) => other.id === rel)) {
+                errors.push({ notationId: n.id, field: 'relationships', message: `Unknown reference: ${rel}` });
+            }
+        }
+    }
+    // Check circular dependencies
+    const cycles = (0, relationship_manager_1.detectCircularDependencies)(notations);
+    for (const cycle of cycles) {
+        errors.push({
+            notationId: cycle[0],
+            field: 'relationships',
+            message: `Circular dependency: ${cycle.join(' → ')}`,
+        });
+    }
+    return errors;
+}

package/dist/scanner/action-parser.d.ts

@@ -0,0 +1,3 @@
+import type { NotationAction } from '../types';
+export declare function parseActions(bodyLines: string[]): NotationAction[];
+//# sourceMappingURL=action-parser.d.ts.map

package/dist/scanner/action-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-parser.d.ts","sourceRoot":"","sources":["../../src/scanner/action-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,UAAU,CAAA;AAmF1D,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,CAkBlE"}