@xelth/eck-snapshot 4.2.4 → 5.4.0

package/src/core/skeletonizer.js

@@ -0,0 +1,201 @@
+import { parse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+const traverse = _traverse.default || _traverse;
+import _generate from '@babel/generator';
+const generate = _generate.default || _generate;
+
+// Lazy-load tree-sitter to avoid breaking when native bindings are unavailable
+let Parser = null;
+let Python = null;
+let Java = null;
+let Kotlin = null;
+let C = null;
+let Rust = null;
+let Go = null;
+
+async function loadTreeSitter() {
+    if (Parser) return true; // Already loaded
+
+    try {
+        // We use dynamic imports and check for basic sanity to handle broken native builds (common on Windows)
+        const treeSitterModule = await import('tree-sitter').catch(() => null);
+        if (!treeSitterModule || !treeSitterModule.default) return false;
+
+        Parser = treeSitterModule.default;
+
+        // Load language packs with Promise.allSettled to handle individual failures
+        const langs = await Promise.allSettled([
+            import('tree-sitter-python'),
+            import('tree-sitter-java'),
+            import('tree-sitter-kotlin'),
+            import('tree-sitter-c'),
+            import('tree-sitter-rust'),
+            import('tree-sitter-go')
+        ]);
+
+        Python = langs[0].status === 'fulfilled' ? langs[0].value.default : null;
+        Java = langs[1].status === 'fulfilled' ? langs[1].value.default : null;
+        Kotlin = langs[2].status === 'fulfilled' ? langs[2].value.default : null;
+        C = langs[3].status === 'fulfilled' ? langs[3].value.default : null;
+        Rust = langs[4].status === 'fulfilled' ? langs[4].value.default : null;
+        Go = langs[5].status === 'fulfilled' ? langs[5].value.default : null;
+
+        return true;
+    } catch (error) {
+        // Silently fail, skeletonize will fallback to original content
+        return false;
+    }
+}
+
+// Initialize parsers map (will be populated lazily)
+const languages = {
+    '.py': () => Python,
+    '.java': () => Java,
+    '.kt': () => Kotlin,
+    '.c': () => C,
+    '.h': () => C,
+    '.cpp': () => C,
+    '.hpp': () => C,
+    '.rs': () => Rust,
+    '.go': () => Go
+};
+
+/**
+ * Strips implementation details from code.
+ * @param {string} content - Full file content
+ * @param {string} filePath - File path to determine language
+ * @returns {Promise<string>} - Skeletonized code
+ */
+export async function skeletonize(content, filePath) {
+    if (!content) return content;
+
+    // 1. JS/TS Strategy (Babel is better for JS ecosystem)
+    if (/\.(js|jsx|ts|tsx|mjs|cjs)$/.test(filePath)) {
+        return skeletonizeJs(content);
+    }
+
+    // 2. Tree-sitter Strategy (Python, Java, Kotlin, C, Rust, Go)
+    const ext = filePath.substring(filePath.lastIndexOf('.'));
+    if (languages[ext]) {
+        // Lazy-load tree-sitter
+        const available = await loadTreeSitter();
+        const langModule = languages[ext]();
+
+        // Only attempt tree-sitter if both the parser and the specific language module are ready
+        if (available && Parser && langModule) {
+            return skeletonizeTreeSitter(content, langModule, ext);
+        }
+        return content; // Fallback: return original content if tree-sitter unavailable
+    }
+
+    // 3. Fallback (Return as is)
+    return content;
+}
+
+function skeletonizeJs(content) {
+    try {
+        const ast = parse(content, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx', 'decorators-legacy'],
+            errorRecovery: true
+        });
+
+        traverse(ast, {
+            Function(path) {
+                if (path.node.body && path.node.body.type === 'BlockStatement') {
+                    // Preserve leading comments (JSDoc) before emptying body
+                    const leadingComments = path.node.leadingComments || [];
+                    path.node.body.body = [];
+                    path.node.body.innerComments = leadingComments.length > 0
+                        ? leadingComments
+                        : [{ type: 'CommentBlock', value: ' ... ' }];
+                }
+            },
+            ClassMethod(path) {
+                if (path.node.body && path.node.body.type === 'BlockStatement') {
+                    // Preserve leading comments (JSDoc) before emptying body
+                    const leadingComments = path.node.leadingComments || [];
+                    path.node.body.body = [];
+                    path.node.body.innerComments = leadingComments.length > 0
+                        ? leadingComments
+                        : [{ type: 'CommentBlock', value: ' ... ' }];
+                }
+            }
+        });
+
+        const output = generate(ast, {}, content);
+        return output.code;
+    } catch (e) {
+        return content + '\n// [Skeleton parse error]';
+    }
+}
+
+function skeletonizeTreeSitter(content, language, ext) {
+    try {
+        const parser = new Parser();
+        parser.setLanguage(language);
+        const tree = parser.parse(content);
+
+        // Define node types that represent function bodies
+        const bodyTypes = ['block', 'function_body', 'compound_statement'];
+        const replacements = [];
+
+        const visit = (node) => {
+            const type = node.type;
+            let isFunction = false;
+            let replacementText = '{ /* ... */ }';
+
+            // Language specific detection
+            if (ext === '.rs') {
+                isFunction = ['function_item', 'method_declaration'].includes(type);
+            } else if (ext === '.go') {
+                isFunction = ['function_declaration', 'method_declaration'].includes(type);
+            } else if (ext === '.py') {
+                isFunction = type === 'function_definition';
+                replacementText = '...';
+            } else {
+                isFunction = [
+                    'function_definition',
+                    'method_declaration',
+                    'function_declaration'
+                ].includes(type);
+            }
+
+            if (isFunction) {
+                let bodyNode = null;
+                for (let i = 0; i < node.childCount; i++) {
+                    const child = node.child(i);
+                    if (bodyTypes.includes(child.type)) {
+                        bodyNode = child;
+                        break;
+                    }
+                }
+
+                if (bodyNode) {
+                    replacements.push({
+                        start: bodyNode.startIndex,
+                        end: bodyNode.endIndex,
+                        text: replacementText
+                    });
+                    return;
+                }
+            }
+
+            for (let i = 0; i < node.childCount; i++) {
+                visit(node.child(i));
+            }
+        };
+
+        visit(tree.rootNode);
+        replacements.sort((a, b) => b.start - a.start);
+
+        let currentContent = content;
+        for (const rep of replacements) {
+            currentContent = currentContent.substring(0, rep.start) + rep.text + currentContent.substring(rep.end);
+        }
+
+        return currentContent;
+    } catch (e) {
+        return content + `\n// [Skeleton error: ${e.message}]`;
+    }
+}

package/src/mcp-server/index.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { execa } from 'execa';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.resolve(__dirname, '../..');
+
+/**
+ * EckSnapshot MCP Server
+ * Provides tools for finalizing development tasks with git integration
+ */
+
+class EckSnapshotMCPServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'ecksnapshot-mcp',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupToolHandlers();
+
+    // Error handling
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  setupToolHandlers() {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'eck_finish_task',
+          description: 'Finalize a completed task by updating AnswerToSA.md, creating a git commit, and generating a delta snapshot. This should be called when a task is fully complete, tested, and ready to be committed. The tool automatically syncs context by running eck-snapshot update-auto.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              status: {
+                type: 'string',
+                description: 'Status update message for AnswerToSA.md (e.g., "Fixed bug X", "Implemented feature Y")',
+              },
+              commitMessage: {
+                type: 'string',
+                description: 'Git commit message. Should follow conventional commits format (e.g., "feat: add user authentication", "fix: resolve login issue")',
+              },
+            },
+            required: ['status', 'commitMessage'],
+          },
+        },
+      ],
+    }));
+
+    // Handle tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name !== 'eck_finish_task') {
+        throw new Error(`Unknown tool: ${request.params.name}`);
+      }
+
+      const { status, commitMessage } = request.params.arguments;
+
+      if (!status || !commitMessage) {
+        throw new Error('Missing required arguments: status and commitMessage are required');
+      }
+
+      try {
+        const result = await this.finishTask(status, commitMessage);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  async finishTask(status, commitMessage) {
+    const workDir = process.cwd();
+    const answerFilePath = path.join(workDir, '.eck', 'lastsnapshot', 'AnswerToSA.md');
+
+    const steps = [];
+
+    // Step 1: Update AnswerToSA.md
+    try {
+      const timestamp = new Date().toISOString();
+      const updateContent = `\n## Update - ${timestamp}\n\n${status}\n`;
+
+      // Check if file exists
+      try {
+        await fs.access(answerFilePath);
+        // Append to existing file
+        await fs.appendFile(answerFilePath, updateContent);
+        steps.push({ step: 'update_answer', success: true, message: 'Updated AnswerToSA.md' });
+      } catch {
+        // Create directory and file if not exists
+        await fs.mkdir(path.dirname(answerFilePath), { recursive: true });
+        await fs.writeFile(answerFilePath, `# Task Status\n${updateContent}`);
+        steps.push({ step: 'update_answer', success: true, message: 'Created AnswerToSA.md' });
+      }
+    } catch (error) {
+      steps.push({ step: 'update_answer', success: false, error: error.message });
+      throw new Error(`Failed to update AnswerToSA.md: ${error.message}`);
+    }
+
+    // Step 2: Git add AnswerToSA.md
+    try {
+      await execa('git', ['add', '.eck/lastsnapshot/AnswerToSA.md'], { cwd: workDir, timeout: 30000 });
+      steps.push({ step: 'git_add_answer', success: true });
+    } catch (error) {
+      steps.push({ step: 'git_add_answer', success: false, error: error.message });
+      throw new Error(`Failed to git add AnswerToSA.md: ${error.message}`);
+    }
+
+    // Step 3: Git add all other changes
+    try {
+      await execa('git', ['add', '.'], { cwd: workDir, timeout: 30000 });
+      steps.push({ step: 'git_add_all', success: true });
+    } catch (error) {
+      steps.push({ step: 'git_add_all', success: false, error: error.message });
+      throw new Error(`Failed to git add all changes: ${error.message}`);
+    }
+
+    // Step 4: Create git commit
+    try {
+      await execa('git', ['commit', '-m', commitMessage], { cwd: workDir, timeout: 30000 });
+      steps.push({ step: 'git_commit', success: true, message: commitMessage });
+    } catch (error) {
+      steps.push({ step: 'git_commit', success: false, error: error.message });
+      throw new Error(`Failed to create commit: ${error.message}`);
+    }
+
+    // Step 5: ALWAYS generate update snapshot (using update-auto for silent JSON output)
+    try {
+      const cliPath = path.join(PROJECT_ROOT, 'index.js');
+      const { stdout } = await execa('node', [cliPath, 'update-auto'], { cwd: workDir, timeout: 120000 });
+
+      // Parse JSON output
+      let snapshotResult;
+      try {
+        snapshotResult = JSON.parse(stdout);
+      } catch {
+        snapshotResult = { raw_output: stdout };
+      }
+
+      steps.push({
+        step: 'update_snapshot',
+        success: snapshotResult.status === 'success',
+        snapshot_file: snapshotResult.snapshot_file,
+        files_count: snapshotResult.files_count,
+        has_agent_report: snapshotResult.has_agent_report,
+        message: snapshotResult.message || 'Delta snapshot generated',
+      });
+    } catch (error) {
+      steps.push({
+        step: 'update_snapshot',
+        success: false,
+        error: error.message,
+        message: 'Snapshot generation failed (non-critical)',
+      });
+      // Don't throw here, snapshot failure shouldn't block task completion
+    }
+
+    return {
+      success: true,
+      message: 'Task finalized successfully',
+      steps,
+      commitMessage,
+    };
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('EckSnapshot MCP server running on stdio');
+  }
+}
+
+// Start the server
+const server = new EckSnapshotMCPServer();
+server.run().catch(console.error);