@mono-labs/tracker 0.1.269 → 0.1.278

package/dist/dashboard/cli.js

@@ -3,8 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("@mono-labs/shared");
 const storage_1 = require("../storage");
 const server_1 = require("./server");
+const scanner_1 = require("../scanner");
+const security_gate_1 = require("../governance/security-gate");
 async function main() {
     const args = process.argv.slice(2);
+    // Check for subcommand
+    if (args[0] === 'gate') {
+        return runGate(args.slice(1));
+    }
     let port = 4321;
     let rootOverride;
     for (let i = 0; i < args.length; i++) {
@@ -32,6 +38,42 @@ async function main() {
     process.on('SIGINT', shutdown);
     process.on('SIGTERM', shutdown);
 }
+async function runGate(args) {
+    let rootOverride;
+    let format = 'text';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--root' && args[i + 1]) {
+            rootOverride = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--format' && args[i + 1]) {
+            format = args[i + 1];
+            i++;
+        }
+    }
+    const { root: detectedRoot } = (0, shared_1.findWorkspaceRoot)(rootOverride);
+    const projectRoot = rootOverride ?? detectedRoot;
+    const config = (0, storage_1.loadConfig)(projectRoot);
+    const notations = await (0, scanner_1.scanFiles)(config, projectRoot);
+    const result = (0, security_gate_1.evaluateSecurityGate)(notations, config);
+    if (format === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        if (result.passed) {
+            console.log(`[tracker] Security gate: PASSED`);
+            console.log(`  ${result.summary}`);
+        }
+        else {
+            console.log(`[tracker] Security gate: FAILED`);
+            console.log(`  ${result.summary}`);
+            for (const v of result.violations) {
+                console.log(`  - [${v.priority}] ${v.notationId}: ${v.description}`);
+            }
+        }
+    }
+    process.exit(result.passed ? 0 : 1);
+}
 main().catch((err) => {
     console.error('[tracker] Failed to start:', err);
     process.exit(1);

package/dist/dashboard/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dashboard/server.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAM/D,wBAAsB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAkIpF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dashboard/server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAkB/D,wBAAsB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CA8dpF"}

package/dist/dashboard/server.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startDashboard = startDashboard;
+const fs_1 = __importDefault(require("fs"));
 const http_1 = __importDefault(require("http"));
 const path_1 = __importDefault(require("path"));
 const express_1 = __importDefault(require("express"));
@@ -11,16 +12,47 @@ const cors_1 = __importDefault(require("cors"));
 const ws_1 = require("ws");
 const manager_1 = require("../manager");
 const scanner_1 = require("../scanner");
+const action_serializer_1 = require("../scanner/action-serializer");
 const watcher_1 = require("./watcher");
+const snapshot_storage_1 = require("../storage/snapshot-storage");
+const config_loader_1 = require("../storage/config-loader");
+const health_score_1 = require("../manager/health-score");
+const security_gate_1 = require("../governance/security-gate");
+const deprecation_tracker_1 = require("../governance/deprecation-tracker");
+const projection_1 = require("../manager/projection");
+const git_blame_1 = require("../scanner/git-blame");
+const executor_1 = require("../executor");
+const github_issues_1 = require("../integrations/github-issues");
+const jira_issues_1 = require("../integrations/jira-issues");
+const ai_suggest_1 = require("../integrations/ai-suggest");
 async function startDashboard(opts) {
     const { projectRoot, config, port = 4321 } = opts;
+    const secrets = (0, config_loader_1.loadSecrets)();
     const manager = new manager_1.NotationManager(config);
+    // Snapshot storage
+    const snapshotPath = path_1.default.isAbsolute(config.snapshotPath)
+        ? config.snapshotPath
+        : path_1.default.join(projectRoot, config.snapshotPath);
+    const snapshotStorage = new snapshot_storage_1.SnapshotStorage(snapshotPath);
     // Initial scan
     const notations = await (0, scanner_1.scanFiles)(config, projectRoot);
     manager.setAll(notations);
+    // Take initial snapshot
+    await takeSnapshotIfNewDay(manager, snapshotStorage);
+    // Optionally run git blame
+    if (config.gitBlame) {
+        runBlameAsync(projectRoot, manager, () => broadcastUpdate());
+    }
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
     app.use(express_1.default.json());
+    // --- Helper to compute current gate result ---
+    function currentGateResult() {
+        return (0, security_gate_1.evaluateSecurityGate)(manager.getAll(), config);
+    }
+    function currentHealthScore() {
+        return (0, health_score_1.computeHealthScore)(manager.getAll());
+    }
     // --- API Routes ---
     app.get('/api/notations', (req, res) => {
         const query = {};
@@ -60,12 +92,26 @@ async function startDashboard(opts) {
         res.json(manager.stats());
     });
     app.get('/api/config', (_req, res) => {
-        res.json({ config, projectRoot });
+        // Strip secrets — never expose tokens
+        const safeConfig = { ...config };
+        res.json({
+            config: safeConfig,
+            projectRoot,
+            integrations: {
+                github: !!config.integrations.github && !!secrets.githubToken,
+                jira: !!config.integrations.jira && !!secrets.jiraToken,
+                ai: !!secrets.aiKey,
+            },
+        });
     });
     app.post('/api/scan', async (_req, res) => {
         try {
             const fresh = await (0, scanner_1.scanFiles)(config, projectRoot);
             manager.setAll(fresh);
+            await takeSnapshotIfNewDay(manager, snapshotStorage);
+            if (config.gitBlame) {
+                runBlameAsync(projectRoot, manager, () => broadcastUpdate());
+            }
             broadcastUpdate();
             res.json({ count: fresh.length });
         }
@@ -73,6 +119,284 @@ async function startDashboard(opts) {
             res.status(500).json({ error: 'Scan failed' });
         }
     });
+    app.get('/api/notations/:id/source', (req, res) => {
+        const notation = manager.getById(req.params.id);
+        if (!notation) {
+            res.status(404).json({ error: 'Notation not found' });
+            return;
+        }
+        try {
+            const filePath = path_1.default.resolve(projectRoot, notation.location.file);
+            const content = fs_1.default.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const startLine = notation.location.line - 1;
+            const endLine = (notation.location.endLine ?? notation.location.line) - 1;
+            const source = lines.slice(startLine, endLine + 1).join('\n');
+            res.json({
+                source,
+                file: notation.location.file,
+                line: notation.location.line,
+                endLine: notation.location.endLine ?? notation.location.line,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to read source file' });
+        }
+    });
+    app.put('/api/notations/:id/source', async (req, res) => {
+        const notation = manager.getById(req.params.id);
+        if (!notation) {
+            res.status(404).json({ error: 'Notation not found' });
+            return;
+        }
+        try {
+            const { source } = req.body;
+            const filePath = path_1.default.resolve(projectRoot, notation.location.file);
+            const content = fs_1.default.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const startLine = notation.location.line - 1;
+            const endLine = (notation.location.endLine ?? notation.location.line) - 1;
+            const newLines = source.split('\n');
+            lines.splice(startLine, endLine - startLine + 1, ...newLines);
+            fs_1.default.writeFileSync(filePath, lines.join('\n'), 'utf-8');
+            const fresh = await (0, scanner_1.scanFiles)(config, projectRoot);
+            manager.setAll(fresh);
+            broadcastUpdate();
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to write source file' });
+        }
+    });
+    app.put('/api/notations/:id/actions', async (req, res) => {
+        const notation = manager.getById(req.params.id);
+        if (!notation) {
+            res.status(404).json({ error: 'Notation not found' });
+            return;
+        }
+        try {
+            const { actions } = req.body;
+            const filePath = path_1.default.resolve(projectRoot, notation.location.file);
+            const content = fs_1.default.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const startLine = notation.location.line - 1;
+            const endLine = (notation.location.endLine ?? notation.location.line) - 1;
+            const blockLines = lines.slice(startLine, endLine + 1);
+            // Remove existing Action: lines
+            const filtered = blockLines.filter((l) => !l.trim().match(/^\/\/\s*Action:\s*/i));
+            // Find where to insert new action lines (after last comment line, before code)
+            let insertIdx = 0;
+            for (let i = 0; i < filtered.length; i++) {
+                if (filtered[i].trim().startsWith('//')) {
+                    insertIdx = i + 1;
+                }
+                else {
+                    break;
+                }
+            }
+            const serialized = (0, action_serializer_1.serializeActions)(actions);
+            filtered.splice(insertIdx, 0, ...serialized);
+            lines.splice(startLine, endLine - startLine + 1, ...filtered);
+            fs_1.default.writeFileSync(filePath, lines.join('\n'), 'utf-8');
+            const fresh = await (0, scanner_1.scanFiles)(config, projectRoot);
+            manager.setAll(fresh);
+            broadcastUpdate();
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to update actions' });
+        }
+    });
+    // --- Snapshot endpoints ---
+    app.get('/api/snapshots', async (req, res) => {
+        try {
+            const days = parseInt(req.query.days) || 30;
+            const snapshots = await snapshotStorage.readRange(days);
+            res.json(snapshots);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to read snapshots' });
+        }
+    });
+    app.get('/api/health', (_req, res) => {
+        res.json({
+            score: currentHealthScore(),
+            deductions: computeHealthScoreDetails(manager.getAll()),
+        });
+    });
+    // --- Governance endpoints ---
+    app.get('/api/governance/gate', (_req, res) => {
+        res.json(currentGateResult());
+    });
+    app.get('/api/governance/deprecations', (_req, res) => {
+        res.json((0, deprecation_tracker_1.computeDeprecationSummary)(manager.getAll()));
+    });
+    // --- Action execution endpoints ---
+    app.post('/api/notations/:id/execute-action', async (req, res) => {
+        const notation = manager.getById(req.params.id);
+        if (!notation) {
+            res.status(404).json({ error: 'Notation not found' });
+            return;
+        }
+        try {
+            const { actionIndex } = req.body;
+            const action = notation.actions[actionIndex];
+            if (!action) {
+                res.status(400).json({ error: 'Action not found at index' });
+                return;
+            }
+            const result = await (0, executor_1.executeAction)(action, notation, projectRoot);
+            // Rescan after execution
+            const fresh = await (0, scanner_1.scanFiles)(config, projectRoot);
+            manager.setAll(fresh);
+            broadcastUpdate();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Action execution failed' });
+        }
+    });
+    app.put('/api/notations/:id/metadata', async (req, res) => {
+        const notation = manager.getById(req.params.id);
+        if (!notation) {
+            res.status(404).json({ error: 'Notation not found' });
+            return;
+        }
+        try {
+            const updates = req.body;
+            updateNotationMetadataInSource(notation, updates, projectRoot);
+            const fresh = await (0, scanner_1.scanFiles)(config, projectRoot);
+            manager.setAll(fresh);
+            broadcastUpdate();
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to update metadata' });
+        }
+    });
+    app.post('/api/notations/batch', async (req, res) => {
+        try {
+            const { ids, operation, payload } = req.body;
+            const results = [];
+            for (const id of ids) {
+                const notation = manager.getById(id);
+                if (!notation)
+                    continue;
+                if (operation === 'executeAction') {
+                    const action = notation.actions[payload.actionIndex];
+                    if (action) {
+                        results.push(await (0, executor_1.executeAction)(action, notation, projectRoot));
+                    }
+                }
+                else {
+                    const updates = {};
+                    if (operation === 'updateStatus')
+                        updates.status = payload.value;
+                    if (operation === 'updatePriority')
+                        updates.priority = payload.value;
+                    if (operation === 'updateAssignee')
+                        updates.assignee = payload.value;
+                    updateNotationMetadataInSource(notation, updates, projectRoot);
+                    results.push({ ok: true, id });
+                }
+            }
+            const fresh = await (0, scanner_1.scanFiles)(config, projectRoot);
+            manager.setAll(fresh);
+            broadcastUpdate();
+            res.json({ results });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Batch operation failed' });
+        }
+    });
+    // --- Git blame endpoint ---
+    app.get('/api/notations/:id/blame', (req, res) => {
+        const notation = manager.getById(req.params.id);
+        if (!notation) {
+            res.status(404).json({ error: 'Notation not found' });
+            return;
+        }
+        res.json({ blame: notation.blame || null });
+    });
+    // --- Issue tracker endpoints ---
+    app.post('/api/notations/:id/create-issue', async (req, res) => {
+        const notation = manager.getById(req.params.id);
+        if (!notation) {
+            res.status(404).json({ error: 'Notation not found' });
+            return;
+        }
+        try {
+            const { provider } = req.body;
+            let issueUrl;
+            if (provider === 'github') {
+                if (!config.integrations.github || !secrets.githubToken) {
+                    res.status(400).json({ error: 'GitHub integration not configured' });
+                    return;
+                }
+                issueUrl = await (0, github_issues_1.createGitHubIssue)(config.integrations.github, secrets.githubToken, notation);
+            }
+            else if (provider === 'jira') {
+                if (!config.integrations.jira || !secrets.jiraToken) {
+                    res.status(400).json({ error: 'Jira integration not configured' });
+                    return;
+                }
+                issueUrl = await (0, jira_issues_1.createJiraIssue)(config.integrations.jira, secrets.jiraToken, notation);
+            }
+            else {
+                res.status(400).json({ error: 'Unknown provider' });
+                return;
+            }
+            // Store the linked issue on the notation
+            manager.update(notation.id, { linkedIssue: issueUrl });
+            broadcastUpdate();
+            res.json({ url: issueUrl });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || 'Failed to create issue' });
+        }
+    });
+    // --- AI suggest fix endpoint ---
+    app.post('/api/notations/:id/suggest-fix', async (req, res) => {
+        const notation = manager.getById(req.params.id);
+        if (!notation) {
+            res.status(404).json({ error: 'Notation not found' });
+            return;
+        }
+        if (!secrets.aiKey) {
+            res.status(400).json({ error: 'AI integration not configured (TRACKER_AI_KEY not set)' });
+            return;
+        }
+        if (notation.type !== 'BUG' && notation.type !== 'OPTIMIZE') {
+            res.status(400).json({ error: 'AI fix suggestions only available for BUG and OPTIMIZE notations' });
+            return;
+        }
+        try {
+            // Read surrounding source context
+            const filePath = path_1.default.resolve(projectRoot, notation.location.file);
+            const content = fs_1.default.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const startLine = Math.max(0, notation.location.line - 26);
+            const endLine = Math.min(lines.length, (notation.location.endLine ?? notation.location.line) + 25);
+            const sourceContext = lines.slice(startLine, endLine).join('\n');
+            const model = config.integrations.ai?.model || 'claude-sonnet-4-5';
+            const result = await (0, ai_suggest_1.suggestFix)(secrets.aiKey, model, notation, sourceContext);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || 'AI suggestion failed' });
+        }
+    });
+    // --- Burn-down projection ---
+    app.get('/api/projection/burndown', async (_req, res) => {
+        try {
+            const snapshots = await snapshotStorage.readAll();
+            const burndown = (0, projection_1.computeBurnDown)(snapshots, manager.getAll());
+            res.json(burndown);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to compute burn-down' });
+        }
+    });
     // --- Static SPA ---
     const distDashboard = path_1.default.join(__dirname, '..', '..', 'dist-dashboard');
     app.use(express_1.default.static(distDashboard));
@@ -82,7 +406,7 @@ async function startDashboard(opts) {
     });
     // --- HTTP + WebSocket ---
     const server = http_1.default.createServer(app);
-    const wss = new ws_1.WebSocketServer({ server });
+    const wss = new ws_1.WebSocketServer({ server, path: '/ws' });
     const clients = new Set();
     wss.on('connection', (ws) => {
         clients.add(ws);
@@ -91,6 +415,8 @@ async function startDashboard(opts) {
             type: 'init',
             notations: manager.getAll(),
             stats: manager.stats(),
+            healthScore: currentHealthScore(),
+            gateResult: currentGateResult(),
         }));
         ws.on('close', () => {
             clients.delete(ws);
@@ -101,6 +427,8 @@ async function startDashboard(opts) {
             type: 'update',
             notations: manager.getAll(),
             stats: manager.stats(),
+            healthScore: currentHealthScore(),
+            gateResult: currentGateResult(),
         });
         for (const client of clients) {
             if (client.readyState === ws_1.WebSocket.OPEN) {
@@ -109,7 +437,13 @@ async function startDashboard(opts) {
         }
     }
     // --- File Watcher ---
-    const watcher = (0, watcher_1.createFileWatcher)(config, projectRoot, manager, broadcastUpdate);
+    const watcher = (0, watcher_1.createFileWatcher)(config, projectRoot, manager, async () => {
+        await takeSnapshotIfNewDay(manager, snapshotStorage);
+        if (config.gitBlame) {
+            runBlameAsync(projectRoot, manager, () => broadcastUpdate());
+        }
+        broadcastUpdate();
+    });
     // --- Start ---
     await new Promise((resolve) => {
         server.listen(port, () => resolve());
@@ -128,3 +462,132 @@ async function startDashboard(opts) {
         },
     };
 }
+// --- Helpers ---
+async function takeSnapshotIfNewDay(manager, snapshotStorage) {
+    const today = new Date().toISOString().slice(0, 10);
+    try {
+        const latestDate = await snapshotStorage.getLatestDate();
+        if (latestDate === today)
+            return;
+        const stats = manager.stats();
+        const healthScore = (0, health_score_1.computeHealthScore)(manager.getAll());
+        await snapshotStorage.append({ date: today, stats, healthScore });
+    }
+    catch (err) {
+        console.error('[tracker] Failed to take snapshot:', err);
+    }
+}
+function runBlameAsync(projectRoot, manager, onComplete) {
+    const notations = manager.getAll();
+    (0, git_blame_1.batchBlame)(projectRoot, notations)
+        .then((blamed) => {
+        for (const n of blamed) {
+            if (n.blame) {
+                manager.update(n.id, { blame: n.blame });
+            }
+        }
+        onComplete();
+    })
+        .catch((err) => {
+        console.error('[tracker] Git blame failed:', err);
+    });
+}
+function computeHealthScoreDetails(notations) {
+    const deductions = [];
+    let unresolvedHacks = 0;
+    let unresolvedBugs = 0;
+    let criticalSecurity = 0;
+    let highSecurity = 0;
+    let overdueCount = 0;
+    let blockedCount = 0;
+    let pastEol = 0;
+    let totalDebt = 0;
+    for (const n of notations) {
+        if (n.status === 'resolved')
+            continue;
+        if (n.type === 'HACK')
+            unresolvedHacks++;
+        if (n.type === 'BUG')
+            unresolvedBugs++;
+        if (n.type === 'SECURITY' && n.priority === 'critical')
+            criticalSecurity++;
+        if (n.type === 'SECURITY' && n.priority === 'high')
+            highSecurity++;
+        if (n.dueDate && new Date(n.dueDate + 'T23:59:59') < new Date())
+            overdueCount++;
+        if (n.relationships.length > 0)
+            blockedCount++;
+        if (n.type === 'DEPRECATION' && n.eolDate && new Date(n.eolDate) < new Date())
+            pastEol++;
+        if (n.debt)
+            totalDebt += n.debt.hours;
+    }
+    if (unresolvedHacks > 0)
+        deductions.push({ reason: `${unresolvedHacks} unresolved HACK(s)`, deduction: unresolvedHacks * 3 });
+    if (unresolvedBugs > 0)
+        deductions.push({ reason: `${unresolvedBugs} unresolved BUG(s)`, deduction: unresolvedBugs * 4 });
+    if (criticalSecurity > 0)
+        deductions.push({ reason: `${criticalSecurity} critical SECURITY issue(s)`, deduction: criticalSecurity * 10 });
+    if (highSecurity > 0)
+        deductions.push({ reason: `${highSecurity} high SECURITY issue(s)`, deduction: highSecurity * 5 });
+    if (overdueCount > 0)
+        deductions.push({ reason: `${overdueCount} overdue notation(s)`, deduction: overdueCount * 2 });
+    if (blockedCount > 0)
+        deductions.push({ reason: `${blockedCount} blocked notation(s)`, deduction: blockedCount * 1 });
+    if (totalDebt > 40)
+        deductions.push({ reason: `${totalDebt}h debt (>${40}h threshold)`, deduction: Math.floor((totalDebt - 40) / 10) });
+    if (pastEol > 0)
+        deductions.push({ reason: `${pastEol} past-EOL deprecation(s)`, deduction: pastEol * 3 });
+    return deductions;
+}
+function updateNotationMetadataInSource(notation, updates, projectRoot) {
+    const filePath = path_1.default.resolve(projectRoot, notation.location.file);
+    const content = fs_1.default.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const startLine = notation.location.line - 1;
+    const endLine = (notation.location.endLine ?? notation.location.line) - 1;
+    const blockLines = lines.slice(startLine, endLine + 1);
+    // Find existing attribute lines or add new ones
+    const attrLines = [];
+    if (updates.status)
+        attrLines.push(`// @status: ${updates.status}`);
+    if (updates.priority)
+        attrLines.push(`// @priority: ${updates.priority}`);
+    if (updates.assignee !== undefined)
+        attrLines.push(`// @assignee: ${updates.assignee}`);
+    // Find insertion point (after marker line, before code)
+    let insertIdx = 1; // After the marker line
+    for (let i = 1; i < blockLines.length; i++) {
+        if (blockLines[i].trim().startsWith('//')) {
+            insertIdx = i + 1;
+        }
+        else {
+            break;
+        }
+    }
+    // Remove existing attribute lines that we're replacing
+    const keysToReplace = Object.keys(updates);
+    const filtered = blockLines.filter((l, idx) => {
+        if (idx === 0)
+            return true; // Keep marker line
+        for (const key of keysToReplace) {
+            const pattern = new RegExp(`^\\s*\\/\\/\\s*@${key}:`, 'i');
+            if (pattern.test(l))
+                return false;
+        }
+        return true;
+    });
+    // Re-find insertion point after filtering
+    insertIdx = 1;
+    for (let i = 1; i < filtered.length; i++) {
+        if (filtered[i].trim().startsWith('//')) {
+            insertIdx = i + 1;
+        }
+        else {
+            break;
+        }
+    }
+    filtered.splice(insertIdx, 0, ...attrLines);
+    lines.splice(startLine, endLine - startLine + 1, ...filtered);
+    fs_1.default.writeFileSync(filePath, lines.join('\n'), 'utf-8');
+}

package/dist/dashboard/watcher.d.ts

@@ -3,5 +3,5 @@ import type { NotationManager } from '../manager';
 export interface FileWatcher {
     close: () => Promise<void>;
 }
-export declare function createFileWatcher(config: TrackerConfig, projectRoot: string, manager: NotationManager, onUpdate: () => void): FileWatcher;
+export declare function createFileWatcher(config: TrackerConfig, projectRoot: string, manager: NotationManager, onUpdate: () => void | Promise<void>): FileWatcher;
 //# sourceMappingURL=watcher.d.ts.map

package/dist/dashboard/watcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../../src/dashboard/watcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAGjD,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,MAAM,IAAI,GAClB,WAAW,CAqCb"}
+{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../../src/dashboard/watcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAGjD,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAClC,WAAW,CAqCb"}

package/dist/dashboard/watcher.js

@@ -15,7 +15,7 @@ function createFileWatcher(config, projectRoot, manager, onUpdate) {
             try {
                 const notations = await (0, scanner_1.scanFiles)(config, projectRoot);
                 manager.setAll(notations);
-                onUpdate();
+                await onUpdate();
             }
             catch (err) {
                 console.error('[tracker] Re-scan failed:', err);

package/dist/executor/action-executor.d.ts

@@ -1,10 +1,10 @@
-import type { NotationAction } from '../types';
+import type { NotationAction, Notation } from '../types';
 export interface ActionResult {
     success: boolean;
     message: string;
     verb: string;
 }
-export type ActionHandler = (action: NotationAction) => Promise<ActionResult>;
+export type ActionHandler = (action: NotationAction, notation: Notation, projectRoot: string) => Promise<ActionResult>;
 export declare function registerActionHandler(verb: string, handler: ActionHandler): void;
-export declare function executeAction(action: NotationAction): Promise<ActionResult>;
+export declare function executeAction(action: NotationAction, notation: Notation, projectRoot: string): Promise<ActionResult>;
 //# sourceMappingURL=action-executor.d.ts.map

package/dist/executor/action-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action-executor.d.ts","sourceRoot":"","sources":["../../src/executor/action-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE9C,MAAM,WAAW,YAAY;IAC5B,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC,YAAY,CAAC,CAAA;AAI7E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAEhF;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC,CAUjF"}
+{"version":3,"file":"action-executor.d.ts","sourceRoot":"","sources":["../../src/executor/action-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExD,MAAM,WAAW,YAAY;IAC5B,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAA;AAItH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAEhF;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAU1H"}

package/dist/executor/action-executor.js

@@ -6,7 +6,7 @@ const handlers = new Map();
 function registerActionHandler(verb, handler) {
     handlers.set(verb, handler);
 }
-async function executeAction(action) {
+async function executeAction(action, notation, projectRoot) {
     const handler = handlers.get(action.verb);
     if (!handler) {
         return {
@@ -15,5 +15,5 @@ async function executeAction(action) {
             verb: action.verb,
         };
     }
-    return handler(action);
+    return handler(action, notation, projectRoot);
 }

package/dist/executor/actions/extract-action.d.ts

@@ -0,0 +1,4 @@
+import type { NotationAction, Notation } from '../../types';
+import type { ActionResult } from '../action-executor';
+export declare function handleExtract(action: NotationAction, notation: Notation, projectRoot: string): Promise<ActionResult>;
+//# sourceMappingURL=extract-action.d.ts.map

package/dist/executor/actions/extract-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-action.d.ts","sourceRoot":"","sources":["../../../src/executor/actions/extract-action.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAe,MAAM,aAAa,CAAA;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAsD1H"}