ronds-mcp-tracker 0.1.6 → 0.1.7

package/dist/config.js

@@ -9,7 +9,6 @@ export const FAILED_QUEUE_CONFIG = {
 };
 function resolveWorkerId() {
     const localConfigPath = path.resolve(process.cwd(), '.ai_config', 'config.json');
-    console.log('[mcp-tracker] localConfigPath:', localConfigPath);
     try {
         if (fs.existsSync(localConfigPath)) {
             const raw = fs.readFileSync(localConfigPath, 'utf-8');

package/dist/server.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { execSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { diffLines } from 'diff';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -40,12 +41,27 @@ function getRepoNameFromGitConfig(cwd) {
         return null;
     }
 }
+function getGitRepoRoot(cwd) {
+    try {
+        const output = execSync('git rev-parse --show-toplevel', {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        });
+        const repoRoot = output.trim();
+        return repoRoot || null;
+    }
+    catch {
+        return null;
+    }
+}
 async function getGitInfo(cwd) {
-    const repoNameFromGitConfig = getRepoNameFromGitConfig(cwd);
+    const repoRoot = getGitRepoRoot(cwd) ?? cwd;
+    const repoNameFromGitConfig = getRepoNameFromGitConfig(repoRoot);
     if (repoNameFromGitConfig) {
-        return { repo_name: repoNameFromGitConfig };
+        return { repo_name: repoNameFromGitConfig, repo_root: repoRoot };
     }
-    const configPath = path.join(cwd, '.gitlab', 'config.json');
+    const configPath = path.join(repoRoot, '.gitlab', 'config.json');
     if (!fs.existsSync(configPath)) {
         return null;
     }
@@ -56,12 +72,25 @@ async function getGitInfo(cwd) {
         if (!repoName) {
             return null;
         }
-        return { repo_name: repoName };
+        return { repo_name: repoName, repo_root: repoRoot };
     }
     catch {
         return null;
     }
 }
+function toRepoRelativePath(filePath, repoRoot) {
+    if (!repoRoot) {
+        return filePath;
+    }
+    const relativePath = path.relative(repoRoot, filePath);
+    if (!relativePath || relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        return filePath;
+    }
+    return relativePath.replace(/\\/g, '/');
+}
+function getKafkaFilePath(filePath, gitInfo) {
+    return toRepoRelativePath(filePath, gitInfo?.repo_root);
+}
 function getAddedLines(oldStr, newStr) {
     const parts = diffLines(oldStr, newStr);
     let lineCount = 0;
@@ -100,6 +129,54 @@ function countDiff(oldStr, newStr) {
 function getFailedDir() {
     return path.join(os.homedir(), '.mcp-tracker', 'failed');
 }
+function getSnapshotsDir() {
+    return path.join(os.homedir(), '.mcp-tracker', 'snapshots');
+}
+function ensureSnapshotsDirExists() {
+    const dir = getSnapshotsDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+function getSnapshotPath(snapshotId) {
+    return path.join(getSnapshotsDir(), `${snapshotId}.json`);
+}
+function cleanupSnapshotsOnStartup() {
+    const dir = ensureSnapshotsDirExists();
+    const entries = fs.readdirSync(dir);
+    let deleted = 0;
+    for (const name of entries) {
+        const filePath = path.join(dir, name);
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile()) {
+            continue;
+        }
+        fs.unlinkSync(filePath);
+        deleted += 1;
+    }
+    return { status: 'cleaned', deleted_count: deleted };
+}
+function saveSnapshot(snapshot) {
+    const dir = ensureSnapshotsDirExists();
+    const filePath = path.join(dir, `${snapshot.snapshot_id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2), 'utf8');
+    return filePath;
+}
+function loadSnapshot(snapshotId) {
+    const filePath = getSnapshotPath(snapshotId);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+function deleteSnapshot(snapshotId) {
+    const filePath = getSnapshotPath(snapshotId);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
 function cleanupFailed(maxAgeHours = 168) {
     const dir = getFailedDir();
     if (!fs.existsSync(dir)) {
@@ -167,16 +244,68 @@ async function replayFailed(maxCount, config) {
     }
     return { status: 'completed', replayed, failed };
 }
+function validateFilePath(filePath) {
+    const normalizedPath = filePath.trim();
+    if (!normalizedPath) {
+        throw new Error('file_path is required');
+    }
+    return normalizedPath;
+}
+function readFileContent(filePath) {
+    return fs.readFileSync(filePath, 'utf8');
+}
+function getFailedEventPath(eventId) {
+    return path.join(getFailedDir(), `${eventId}.json`);
+}
+function handleBeforeEdit(input) {
+    const filePath = validateFilePath(input.file_path);
+    const content = readFileContent(filePath);
+    const snapshotId = randomUUID();
+    saveSnapshot({
+        snapshot_id: snapshotId,
+        file_path: filePath,
+        created_at: new Date().toISOString(),
+        content
+    });
+    return JSON.stringify({
+        status: 'snapshotted',
+        snapshot_id: snapshotId,
+        file_path: filePath
+    });
+}
 async function handleAfterEdit(input, config) {
-    const addedLines = getAddedLines(input.old_string, input.new_string);
-    const diffStats = countDiff(input.old_string, input.new_string);
+    const filePath = validateFilePath(input.file_path);
+    const snapshotId = input.snapshot_id?.trim();
+    if (!snapshotId) {
+        throw new Error('snapshot_id is required');
+    }
+    const snapshot = loadSnapshot(snapshotId);
+    if (!snapshot) {
+        return JSON.stringify({
+            status: 'snapshot_not_found',
+            snapshot_id: snapshotId,
+            file_path: filePath
+        });
+    }
+    if (snapshot.file_path !== filePath) {
+        return JSON.stringify({
+            status: 'snapshot_file_path_mismatch',
+            snapshot_id: snapshotId,
+            file_path: filePath,
+            snapshot_file_path: snapshot.file_path
+        });
+    }
+    const oldStr = snapshot.content;
+    const newStr = readFileContent(filePath);
+    const addedLines = getAddedLines(oldStr, newStr);
+    const diffStats = countDiff(oldStr, newStr);
     const gitInfo = await getGitInfo(process.cwd());
     const event = {
         event_id: randomUUID(),
         timestamp: new Date().toISOString(),
         worker_id: config.worker_id,
-        git: gitInfo,
-        file: { path: input.file_path, operation: 'edit' },
+        git: gitInfo ? { repo_name: gitInfo.repo_name } : null,
+        file: { path: getKafkaFilePath(filePath, gitInfo), operation: 'edit' },
         changes: {
             added_content: addedLines,
             added: diffStats.added,
@@ -184,6 +313,16 @@ async function handleAfterEdit(input, config) {
         }
     };
     await publishToKafka(config, event);
+    if (fs.existsSync(getFailedEventPath(event.event_id))) {
+        return JSON.stringify({
+            status: 'queued_for_retry',
+            event_id: event.event_id,
+            snapshot_id: snapshotId,
+            lines_changed: diffStats.added + diffStats.removed,
+            added_content: addedLines
+        });
+    }
+    deleteSnapshot(snapshotId);
     return JSON.stringify({
         status: 'recorded',
         event_id: event.event_id,
@@ -201,17 +340,27 @@ async function handleReplayFailed(input, config) {
     const result = await replayFailed(maxCount, config);
     return JSON.stringify({ status: result.status, replayed: result.replayed, failed: result.failed });
 }
+const BEFORE_EDIT_TOOL_SCHEMA = {
+    name: 'before_edit',
+    description: 'Save a server-side snapshot before file edits.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string' }
+        },
+        required: ['file_path']
+    }
+};
 const AFTER_EDIT_TOOL_SCHEMA = {
     name: 'after_edit',
-    description: 'Record code changes after file edits.',
+    description: 'Record code changes after file edits using a saved snapshot.',
     inputSchema: {
         type: 'object',
         properties: {
             file_path: { type: 'string' },
-            old_string: { type: 'string' },
-            new_string: { type: 'string' }
+            snapshot_id: { type: 'string' }
         },
-        required: ['file_path', 'old_string', 'new_string']
+        required: ['file_path', 'snapshot_id']
     }
 };
 const CLEANUP_FAILED_TOOL_SCHEMA = {
@@ -236,6 +385,7 @@ const REPLAY_FAILED_TOOL_SCHEMA = {
 };
 async function main() {
     const config = loadConfig();
+    cleanupSnapshotsOnStartup();
     await initProducer(config);
     const server = new Server({
         name: 'code-change-tracker',
@@ -246,11 +396,15 @@ async function main() {
         }
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [AFTER_EDIT_TOOL_SCHEMA, CLEANUP_FAILED_TOOL_SCHEMA, REPLAY_FAILED_TOOL_SCHEMA]
+        tools: [BEFORE_EDIT_TOOL_SCHEMA, AFTER_EDIT_TOOL_SCHEMA, CLEANUP_FAILED_TOOL_SCHEMA, REPLAY_FAILED_TOOL_SCHEMA]
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const name = request.params.name;
         const input = request.params.arguments ?? {};
+        if (name === 'before_edit') {
+            const result = handleBeforeEdit(input);
+            return { content: [{ type: 'text', text: result }] };
+        }
         if (name === 'after_edit') {
             const result = await handleAfterEdit(input, config);
             return { content: [{ type: 'text', text: result }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ronds-mcp-tracker",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "bin": {
     "ronds-mcp-tracker": "./bin/cli.js"