@mono-labs/tracker 0.1.269

package/dist/scanner/notation-parser.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFileContent = parseFileContent;
+const enums_1 = require("../types/enums");
+const utils_1 = require("../utils");
+const attribute_parser_1 = require("./attribute-parser");
+const action_parser_1 = require("./action-parser");
+const MARKER_REGEX = /^(\s*)\/\/\s*(FIXME|TODO|BUG|HACK|NOTE|OPTIMIZE|SECURITY):?\s*(?:\[([^\]]*)\])?\s*(.*)/;
+function parseFileContent(filePath, content, idPrefix = 'N') {
+    const lines = content.split('\n');
+    const notations = [];
+    let i = 0;
+    while (i < lines.length) {
+        const match = lines[i].match(MARKER_REGEX);
+        if (!match) {
+            i++;
+            continue;
+        }
+        const indent = match[1];
+        const markerType = match[2];
+        const inlineId = match[3] || undefined;
+        const description = match[4].trim();
+        const startLine = i + 1; // 1-indexed
+        const column = indent.length + 1;
+        // Collect continuation lines (// lines that aren't new markers)
+        const bodyLines = [];
+        const rawLines = [lines[i]];
+        i++;
+        while (i < lines.length) {
+            const nextLine = lines[i];
+            // Stop if it's a new marker
+            if (MARKER_REGEX.test(nextLine))
+                break;
+            // Stop if not a comment line
+            const commentMatch = nextLine.match(/^\s*\/\/\s?(.*)/);
+            if (!commentMatch)
+                break;
+            bodyLines.push(commentMatch[1]);
+            rawLines.push(nextLine);
+            i++;
+        }
+        // Collect code context lines (non-empty, non-comment lines until blank)
+        const codeContext = [];
+        while (i < lines.length) {
+            const codeLine = lines[i];
+            if (codeLine.trim() === '')
+                break;
+            if (/^\s*\/\//.test(codeLine))
+                break;
+            codeContext.push(codeLine);
+            rawLines.push(codeLine);
+            i++;
+        }
+        const endLine = startLine + rawLines.length - 1;
+        const id = inlineId || (0, utils_1.generateStableId)(idPrefix, filePath, startLine);
+        const attrs = (0, attribute_parser_1.parseAttributes)(bodyLines);
+        const actions = (0, action_parser_1.parseActions)(bodyLines);
+        const notation = {
+            id,
+            type: markerType,
+            description,
+            body: bodyLines,
+            codeContext,
+            location: {
+                file: filePath,
+                line: startLine,
+                column,
+                endLine,
+            },
+            author: attrs.author,
+            assignee: attrs.assignee,
+            priority: attrs.priority,
+            risk: attrs.risk,
+            status: enums_1.Status.OPEN,
+            tags: attrs.tags,
+            dueDate: attrs.dueDate,
+            createdDate: attrs.createdDate,
+            performance: attrs.performance,
+            debt: attrs.debt,
+            actions,
+            relationships: attrs.relationships,
+            rawBlock: rawLines.join('\n'),
+            scannedAt: new Date().toISOString(),
+        };
+        notations.push(notation);
+    }
+    return notations;
+}

package/dist/scanner/notation-parser.test.d.ts

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

package/dist/scanner/notation-parser.test.d.ts.map

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

package/dist/scanner/notation-parser.test.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const notation_parser_1 = require("./notation-parser");
+(0, vitest_1.describe)('parseFileContent', () => {
+    (0, vitest_1.it)('parses a simple TODO', () => {
+        const content = '// TODO: Fix this bug';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].type).toBe('TODO');
+        (0, vitest_1.expect)(result[0].description).toBe('Fix this bug');
+    });
+    (0, vitest_1.it)('parses a FIXME marker', () => {
+        const content = '// FIXME: Memory leak in handler';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].type).toBe('FIXME');
+    });
+    (0, vitest_1.it)('parses a BUG marker', () => {
+        const content = '// BUG: Null pointer exception';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].type).toBe('BUG');
+    });
+    (0, vitest_1.it)('parses a HACK marker', () => {
+        const content = '// HACK: Temporary workaround';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].type).toBe('HACK');
+    });
+    (0, vitest_1.it)('parses a NOTE marker', () => {
+        const content = '// NOTE: This is intentional';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].type).toBe('NOTE');
+    });
+    (0, vitest_1.it)('parses an OPTIMIZE marker', () => {
+        const content = '// OPTIMIZE: Use batch query';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].type).toBe('OPTIMIZE');
+    });
+    (0, vitest_1.it)('parses a SECURITY marker', () => {
+        const content = '// SECURITY: Validate input';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].type).toBe('SECURITY');
+    });
+    (0, vitest_1.it)('extracts inline id from brackets', () => {
+        const content = '// TODO [TASK-123] Implement feature';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].id).toBe('TASK-123');
+    });
+    (0, vitest_1.it)('collects continuation comment lines', () => {
+        const content = [
+            '// TODO: Main description',
+            '// @author: Cody Jones',
+            '// @priority: high',
+        ].join('\n');
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].body).toHaveLength(2);
+        (0, vitest_1.expect)(result[0].author).toBe('Cody Jones');
+        (0, vitest_1.expect)(result[0].priority).toBe('high');
+    });
+    (0, vitest_1.it)('collects code context lines', () => {
+        const content = [
+            '// TODO: Fix this function',
+            'function broken() {',
+            '  return null',
+            '}',
+        ].join('\n');
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].codeContext).toHaveLength(3);
+        (0, vitest_1.expect)(result[0].codeContext[0]).toBe('function broken() {');
+    });
+    (0, vitest_1.it)('stops code context at blank line', () => {
+        const content = [
+            '// TODO: Fix this',
+            'const x = 1',
+            '',
+            'const y = 2',
+        ].join('\n');
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].codeContext).toHaveLength(1);
+    });
+    (0, vitest_1.it)('parses adjacent markers separately', () => {
+        const content = [
+            '// TODO: First task',
+            '// FIXME: Second task',
+        ].join('\n');
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result).toHaveLength(2);
+        (0, vitest_1.expect)(result[0].type).toBe('TODO');
+        (0, vitest_1.expect)(result[1].type).toBe('FIXME');
+    });
+    (0, vitest_1.it)('sets correct line numbers (1-indexed)', () => {
+        const content = [
+            'const x = 1',
+            '// TODO: Found on line 2',
+            'const y = 2',
+        ].join('\n');
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].location.line).toBe(2);
+    });
+    (0, vitest_1.it)('sets correct file path', () => {
+        const content = '// TODO: Test';
+        const result = (0, notation_parser_1.parseFileContent)('src/app.ts', content);
+        (0, vitest_1.expect)(result[0].location.file).toBe('src/app.ts');
+    });
+    (0, vitest_1.it)('parses indented markers', () => {
+        const content = '    // TODO: Indented task';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].location.column).toBe(5);
+    });
+    (0, vitest_1.it)('parses marker without colon', () => {
+        const content = '// TODO Fix without colon';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].description).toBe('Fix without colon');
+    });
+    (0, vitest_1.it)('handles multi-line with actions', () => {
+        const content = [
+            '// TODO: Refactor handler',
+            '// Action: replace(oldFn, newFn)',
+        ].join('\n');
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].actions).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].actions[0].args.verb).toBe('replace');
+    });
+    (0, vitest_1.it)('generates stable ids when no inline id', () => {
+        const content = '// TODO: No id here';
+        const r1 = (0, notation_parser_1.parseFileContent)('test.ts', content, 'N');
+        const r2 = (0, notation_parser_1.parseFileContent)('test.ts', content, 'N');
+        (0, vitest_1.expect)(r1[0].id).toBe(r2[0].id);
+    });
+    (0, vitest_1.it)('handles empty content', () => {
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', '');
+        (0, vitest_1.expect)(result).toHaveLength(0);
+    });
+    (0, vitest_1.it)('handles content with no markers', () => {
+        const content = 'const x = 1\nconst y = 2';
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result).toHaveLength(0);
+    });
+    (0, vitest_1.it)('preserves raw block', () => {
+        const content = [
+            '// TODO: Raw block test',
+            '// with continuation',
+            'const x = 1',
+        ].join('\n');
+        const result = (0, notation_parser_1.parseFileContent)('test.ts', content);
+        (0, vitest_1.expect)(result[0].rawBlock).toContain('TODO: Raw block test');
+        (0, vitest_1.expect)(result[0].rawBlock).toContain('with continuation');
+        (0, vitest_1.expect)(result[0].rawBlock).toContain('const x = 1');
+    });
+});

package/dist/storage/config-loader.d.ts

@@ -0,0 +1,3 @@
+import type { TrackerConfig } from '../types';
+export declare function loadConfig(projectRoot: string): TrackerConfig;
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/storage/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../src/storage/config-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAG7C,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAgB7D"}

package/dist/storage/config-loader.js

@@ -0,0 +1,55 @@
+"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.loadConfig = loadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("../types");
+function loadConfig(projectRoot) {
+    const configPath = path.join(projectRoot, 'tracker.config.json');
+    let userConfig = {};
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        userConfig = JSON.parse(raw);
+    }
+    catch {
+        // No config file or invalid JSON — use defaults
+    }
+    return {
+        ...types_1.DEFAULT_CONFIG,
+        ...userConfig,
+        rootDir: projectRoot,
+    };
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,3 @@
+export { JsonlStorage } from './jsonl-storage';
+export { loadConfig } from './config-loader';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/storage/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = exports.JsonlStorage = void 0;
+var jsonl_storage_1 = require("./jsonl-storage");
+Object.defineProperty(exports, "JsonlStorage", { enumerable: true, get: function () { return jsonl_storage_1.JsonlStorage; } });
+var config_loader_1 = require("./config-loader");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_loader_1.loadConfig; } });

package/dist/storage/jsonl-storage.d.ts

@@ -0,0 +1,11 @@
+import type { Notation } from '../types';
+export declare class JsonlStorage {
+    private filePath;
+    constructor(filePath: string);
+    ensureDirectory(): Promise<void>;
+    readAll(): Promise<Notation[]>;
+    writeAll(notations: Notation[]): Promise<void>;
+    append(notation: Notation): Promise<void>;
+    appendBatch(notations: Notation[]): Promise<void>;
+}
+//# sourceMappingURL=jsonl-storage.d.ts.map

package/dist/storage/jsonl-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-storage.d.ts","sourceRoot":"","sources":["../../src/storage/jsonl-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC,qBAAa,YAAY;IACxB,OAAO,CAAC,QAAQ,CAAQ;gBAEZ,QAAQ,EAAE,MAAM;IAItB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAKhC,OAAO,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAmB9B,QAAQ,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ9C,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzC,WAAW,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAMvD"}

package/dist/storage/jsonl-storage.js

@@ -0,0 +1,88 @@
+"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.JsonlStorage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class JsonlStorage {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async ensureDirectory() {
+        const dir = path.dirname(this.filePath);
+        await fs.promises.mkdir(dir, { recursive: true });
+    }
+    async readAll() {
+        try {
+            const content = await fs.promises.readFile(this.filePath, 'utf-8');
+            const lines = content.trim().split('\n').filter(Boolean);
+            const notations = [];
+            for (const line of lines) {
+                try {
+                    notations.push(JSON.parse(line));
+                }
+                catch {
+                    // Skip corrupt lines
+                }
+            }
+            return notations;
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return [];
+            throw err;
+        }
+    }
+    async writeAll(notations) {
+        await this.ensureDirectory();
+        const tmpPath = this.filePath + '.tmp';
+        const content = notations.map((n) => JSON.stringify(n)).join('\n') + '\n';
+        await fs.promises.writeFile(tmpPath, content, 'utf-8');
+        await fs.promises.rename(tmpPath, this.filePath);
+    }
+    async append(notation) {
+        await this.ensureDirectory();
+        await fs.promises.appendFile(this.filePath, JSON.stringify(notation) + '\n', 'utf-8');
+    }
+    async appendBatch(notations) {
+        if (notations.length === 0)
+            return;
+        await this.ensureDirectory();
+        const content = notations.map((n) => JSON.stringify(n)).join('\n') + '\n';
+        await fs.promises.appendFile(this.filePath, content, 'utf-8');
+    }
+}
+exports.JsonlStorage = JsonlStorage;

package/dist/storage/jsonl-storage.test.d.ts

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

package/dist/storage/jsonl-storage.test.d.ts.map

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

package/dist/storage/jsonl-storage.test.js

@@ -0,0 +1,126 @@
+"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 });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const jsonl_storage_1 = require("./jsonl-storage");
+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 notation',
+        scannedAt: '2026-01-01T00:00:00.000Z',
+        ...overrides,
+    };
+}
+(0, vitest_1.describe)('JsonlStorage', () => {
+    let tmpDir;
+    let storage;
+    (0, vitest_1.beforeEach)(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tracker-test-'));
+        storage = new jsonl_storage_1.JsonlStorage(path.join(tmpDir, 'data', 'notations.jsonl'));
+    });
+    (0, vitest_1.afterEach)(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)('returns empty array when file does not exist', async () => {
+        const result = await storage.readAll();
+        (0, vitest_1.expect)(result).toEqual([]);
+    });
+    (0, vitest_1.it)('round-trips notations through writeAll/readAll', async () => {
+        const notations = [makeNotation({ id: 'N-1' }), makeNotation({ id: 'N-2' })];
+        await storage.writeAll(notations);
+        const result = await storage.readAll();
+        (0, vitest_1.expect)(result).toHaveLength(2);
+        (0, vitest_1.expect)(result[0].id).toBe('N-1');
+        (0, vitest_1.expect)(result[1].id).toBe('N-2');
+    });
+    (0, vitest_1.it)('appends a single notation', async () => {
+        await storage.append(makeNotation({ id: 'N-1' }));
+        await storage.append(makeNotation({ id: 'N-2' }));
+        const result = await storage.readAll();
+        (0, vitest_1.expect)(result).toHaveLength(2);
+    });
+    (0, vitest_1.it)('appends a batch of notations', async () => {
+        await storage.appendBatch([
+            makeNotation({ id: 'N-1' }),
+            makeNotation({ id: 'N-2' }),
+            makeNotation({ id: 'N-3' }),
+        ]);
+        const result = await storage.readAll();
+        (0, vitest_1.expect)(result).toHaveLength(3);
+    });
+    (0, vitest_1.it)('skips corrupt lines gracefully', async () => {
+        const filePath = path.join(tmpDir, 'data', 'notations.jsonl');
+        await storage.ensureDirectory();
+        fs.writeFileSync(filePath, [
+            JSON.stringify(makeNotation({ id: 'N-1' })),
+            'this is not valid json{{{',
+            JSON.stringify(makeNotation({ id: 'N-2' })),
+        ].join('\n') + '\n');
+        const result = await storage.readAll();
+        (0, vitest_1.expect)(result).toHaveLength(2);
+        (0, vitest_1.expect)(result[0].id).toBe('N-1');
+        (0, vitest_1.expect)(result[1].id).toBe('N-2');
+    });
+    (0, vitest_1.it)('creates directory on write', async () => {
+        const nested = new jsonl_storage_1.JsonlStorage(path.join(tmpDir, 'a', 'b', 'c', 'data.jsonl'));
+        await nested.writeAll([makeNotation()]);
+        const result = await nested.readAll();
+        (0, vitest_1.expect)(result).toHaveLength(1);
+    });
+    (0, vitest_1.it)('overwrites existing data on writeAll', async () => {
+        await storage.writeAll([makeNotation({ id: 'N-1' }), makeNotation({ id: 'N-2' })]);
+        await storage.writeAll([makeNotation({ id: 'N-3' })]);
+        const result = await storage.readAll();
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].id).toBe('N-3');
+    });
+    (0, vitest_1.it)('handles empty batch append', async () => {
+        await storage.appendBatch([]);
+        const result = await storage.readAll();
+        (0, vitest_1.expect)(result).toEqual([]);
+    });
+});

package/dist/types/action.d.ts

@@ -0,0 +1,57 @@
+export declare const ActionVerb: {
+    readonly REPLACE: "replace";
+    readonly REMOVE: "remove";
+    readonly RENAME: "rename";
+    readonly INSERT: "insert";
+    readonly EXTRACT: "extract";
+    readonly MOVE: "move";
+    readonly WRAP_IN: "wrapIn";
+    readonly GENERIC: "generic";
+};
+export type ActionVerb = (typeof ActionVerb)[keyof typeof ActionVerb];
+export interface ReplaceArgs {
+    verb: typeof ActionVerb.REPLACE;
+    target: string;
+    replacement: string;
+}
+export interface RemoveArgs {
+    verb: typeof ActionVerb.REMOVE;
+    target: string;
+}
+export interface RenameArgs {
+    verb: typeof ActionVerb.RENAME;
+    from: string;
+    to: string;
+}
+export interface InsertArgs {
+    verb: typeof ActionVerb.INSERT;
+    content: string;
+    position: 'before' | 'after';
+    anchor: string;
+}
+export interface ExtractArgs {
+    verb: typeof ActionVerb.EXTRACT;
+    target: string;
+    destination: string;
+}
+export interface MoveArgs {
+    verb: typeof ActionVerb.MOVE;
+    target: string;
+    destination: string;
+}
+export interface WrapInArgs {
+    verb: typeof ActionVerb.WRAP_IN;
+    target: string;
+    wrapper: string;
+}
+export interface GenericArgs {
+    verb: typeof ActionVerb.GENERIC;
+    description: string;
+}
+export type ActionArgs = ReplaceArgs | RemoveArgs | RenameArgs | InsertArgs | ExtractArgs | MoveArgs | WrapInArgs | GenericArgs;
+export interface NotationAction {
+    verb: ActionVerb;
+    raw: string;
+    args: ActionArgs;
+}
+//# sourceMappingURL=action.d.ts.map

package/dist/types/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/types/action.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;CASb,CAAA;AACV,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAA;AAErE,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,OAAO,UAAU,CAAC,OAAO,CAAA;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,OAAO,UAAU,CAAC,MAAM,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,OAAO,UAAU,CAAC,MAAM,CAAA;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,OAAO,UAAU,CAAC,MAAM,CAAA;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAA;IAC5B,MAAM,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,OAAO,UAAU,CAAC,OAAO,CAAA;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,OAAO,UAAU,CAAC,IAAI,CAAA;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,OAAO,UAAU,CAAC,OAAO,CAAA;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,OAAO,UAAU,CAAC,OAAO,CAAA;IAC/B,WAAW,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,UAAU,GACnB,WAAW,GACX,UAAU,GACV,UAAU,GACV,UAAU,GACV,WAAW,GACX,QAAQ,GACR,UAAU,GACV,WAAW,CAAA;AAEd,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,UAAU,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,UAAU,CAAA;CAChB"}

package/dist/types/action.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionVerb = void 0;
+exports.ActionVerb = {
+    REPLACE: 'replace',
+    REMOVE: 'remove',
+    RENAME: 'rename',
+    INSERT: 'insert',
+    EXTRACT: 'extract',
+    MOVE: 'move',
+    WRAP_IN: 'wrapIn',
+    GENERIC: 'generic',
+};

package/dist/types/config.d.ts

@@ -0,0 +1,11 @@
+import type { MarkerType } from './enums';
+export interface TrackerConfig {
+    rootDir: string;
+    include: string[];
+    exclude: string[];
+    markers: MarkerType[];
+    storagePath: string;
+    idPrefix: string;
+}
+export declare const DEFAULT_CONFIG: TrackerConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/types/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;CAChB;AAED,eAAO,MAAM,cAAc,EAAE,aAO5B,CAAA"}