sdlc-agent-4-enterprise-server 1.0.0

package/extension/webview-assets/workflow-graph.js

@@ -0,0 +1,108 @@
+/**
+ * Workflow Graph — 3D Force-Graph with canvas sprite labels
+ * Key fix: uses THREE.Texture(canvas) NOT THREE.CanvasTexture for VS Code webview compat.
+ */
+/* global vscode, ForceGraph3D, THREE */
+
+let graphState = { nodes: [], edges: [], selectedPhase: null, graph3d: null };
+const NODE_COLORS = { agent: "#3b82f6", quality_gate: "#10b981", verify: "#f59e0b", security: "#ef4444", control: "#8b5cf6" };
+const PHASES = [
+  { id: "all", label: "ALL", nodes: null },
+  { id: "phase1", label: "P1:BRD", nodes: ["ba_brd", "verify_ba_brd", "quality_gate_requirements"] },
+  { id: "phase2", label: "P2:FSD", nodes: ["ba_fsd", "verify_ba_fsd", "ta_enrich", "security_review_fsd", "quality_gate_specification"] },
+  { id: "phase3", label: "P3:TDD", nodes: ["sa_tdd", "verify_sa_tdd", "feedback_check", "ba_fix_fsd", "sa_review", "security_review_tdd", "quality_gate_design"] },
+  { id: "phase4", label: "P4:QA", nodes: ["qa_plan", "verify_qa_plan", "quality_gate_test_planning"] },
+  { id: "phase5", label: "P5:Code", nodes: ["dev_code", "verify_dev_code", "security_review_code", "quality_gate_implementation"] },
+  { id: "phase55", label: "P5.5:UG", nodes: ["dev_ug", "verify_dev_ug", "ba_review_ug", "qa_verify_ug", "ug_join", "quality_gate_user_guide"] },
+  { id: "phase6", label: "P6:Test", nodes: ["qa_test", "quality_gate_testing"] },
+  { id: "phase7", label: "P7:Deploy", nodes: ["devops_deploy", "quality_gate_deployment"] },
+];
+
+function handlePanelMessage(msg) {
+  if (msg.type === "workflowData") {
+    graphState.nodes = msg.nodes || [];
+    graphState.edges = msg.edges || [];
+    renderPhaseBar();
+    render3DGraph(null);
+  }
+}
+
+function renderPhaseBar() {
+  const bar = document.getElementById("phase-bar");
+  if (!bar) return;
+  bar.innerHTML = "";
+  PHASES.forEach(phase => {
+    const btn = document.createElement("button");
+    btn.className = "phase-btn" + ((graphState.selectedPhase || "all") === phase.id ? " active" : "");
+    btn.textContent = phase.label;
+    btn.addEventListener("click", () => { graphState.selectedPhase = phase.id; renderPhaseBar(); render3DGraph(phase.nodes ? phase : null); });
+    bar.appendChild(btn);
+  });
+}
+
+function render3DGraph(filterPhase) {
+  const container = document.getElementById("graph-3d");
+  if (!container) return;
+  container.innerHTML = "";
+
+  let visibleNodeIds;
+  if (filterPhase && filterPhase.nodes) { visibleNodeIds = new Set(filterPhase.nodes); }
+  else { visibleNodeIds = new Set(graphState.nodes.map(n => n.id)); }
+
+  const nodes = graphState.nodes.filter(n => visibleNodeIds.has(n.id)).map(n => ({
+    id: n.id, label: n.label, type: n.type, color: NODE_COLORS[n.type] || "#888",
+    val: n.type === "agent" ? 4 : n.type === "quality_gate" ? 3 : 2
+  }));
+  const nodeIdSet = new Set(nodes.map(n => n.id));
+  const links = graphState.edges.filter(e => nodeIdSet.has(e.source) && nodeIdSet.has(e.target)).map(e => ({ source: e.source, target: e.target, label: e.label || "", type: e.type }));
+
+  const Graph = ForceGraph3D()(container)
+    .width(container.clientWidth || 800)
+    .height(container.clientHeight || 500)
+    .graphData({ nodes, links })
+    .backgroundColor("rgba(0,0,0,0)")
+    .nodeLabel(n => n.label + " [" + n.type + "]")
+    .nodeColor(n => n.color)
+    .nodeVal(n => n.val)
+    .nodeOpacity(0.9)
+    .linkColor(l => l.type === "conditional" ? "rgba(180,180,180,0.2)" : "rgba(220,220,220,0.35)")
+    .linkWidth(l => l.type === "conditional" ? 0.3 : 0.7)
+    .linkDirectionalArrowLength(3.5)
+    .linkDirectionalArrowRelPos(1)
+    .linkDirectionalArrowColor(() => "rgba(220,220,220,0.5)")
+    .linkLabel(l => l.label)
+    .onNodeClick(node => {
+      const dist = 100, ratio = 1 + dist / Math.hypot(node.x, node.y, node.z);
+      Graph.cameraPosition({ x: node.x * ratio, y: node.y * ratio, z: node.z * ratio }, node, 800);
+      showNodeInfo(node);
+    })
+    .onNodeHover(node => { container.style.cursor = node ? "pointer" : "default"; });
+
+  // No custom objects - just use default spheres. Labels show on hover (native tooltip).
+  graphState.graph3d = Graph;
+  new ResizeObserver(() => { const w = container.clientWidth, h = container.clientHeight; if (w > 0 && h > 0) Graph.width(w).height(h); }).observe(container);
+  renderLegend();
+}
+
+function renderLegend() {
+  let el = document.getElementById("legend-3d");
+  if (!el) { el = document.createElement("div"); el.id = "legend-3d"; document.body.appendChild(el); }
+  el.innerHTML = [
+    { c: "#3b82f6", l: "Agent" }, { c: "#10b981", l: "Quality Gate" }, { c: "#f59e0b", l: "Verify" }, { c: "#ef4444", l: "Security" }, { c: "#8b5cf6", l: "Control" }
+  ].map(i => '<div class="legend-item"><span class="legend-dot" style="background:' + i.c + '"></span>' + i.l + '</div>').join("");
+}
+
+function showNodeInfo(node) {
+  const info = document.getElementById("node-info");
+  if (!info) return;
+  const up = graphState.edges.filter(e => e.target === node.id).map(e => { const n = graphState.nodes.find(x => x.id === e.source); return n ? n.label : e.source; });
+  const down = graphState.edges.filter(e => e.source === node.id).map(e => { const n = graphState.nodes.find(x => x.id === e.target); return (n ? n.label : e.target) + (e.label ? " (" + e.label + ")" : ""); });
+  info.innerHTML = "<strong>" + node.label + "</strong> <span class='info-type'>" + node.type + "</span>" +
+    (up.length ? "<div class='info-section'><span class='info-dir'>&#x2191;</span> " + up.join(", ") + "</div>" : "") +
+    (down.length ? "<div class='info-section'><span class='info-dir'>&#x2193;</span> " + down.join(", ") + "</div>" : "");
+  info.classList.remove("hidden");
+}
+
+document.addEventListener("DOMContentLoaded", () => {
+  document.getElementById("refresh-btn")?.addEventListener("click", () => vscode.postMessage({ type: "refresh" }));
+});

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "sdlc-agent-4-enterprise-server",
+  "version": "1.0.0",
+  "description": "Code Intelligence MCP Server — multi-agent SDLC pipeline with semantic memory, code graph, and draw.io integration",
+  "main": "dist/index.js",
+  "bin": {
+    "sdlc-agent-4-enterprise-server": "dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run src/",
+    "test:integration": "vitest run tests/integration/",
+    "test:e2e-api": "vitest run tests/e2e/",
+    "test:e2e-ui": "npx playwright test"
+  },
+  "keywords": [
+    "mcp",
+    "code-intelligence",
+    "sdlc",
+    "agents",
+    "memory",
+    "knowledge-base",
+    "draw.io"
+  ],
+  "author": "SA4E Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dnguyenminh/SDLC-Agents-4-Enteprise.git"
+  },
+  "engines": {
+    "node": ">=18.14.1"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.12.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@xenova/transformers": "^2.0.1",
+    "better-sqlite3": "^11.10.0",
+    "chokidar": "^5.0.0",
+    "hono": "^4.0.0",
+    "onnxruntime-node": "^1.18.0",
+    "pino": "^9.2.0",
+    "web-tree-sitter": "^0.26.9",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.60.0",
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^4.1.9",
+    "@types/express": "^5.0.0"
+  }
+}

package/scripts/debug/check_tools.js

@@ -0,0 +1,76 @@
+// Usage: node check_tools.js [baseUrl]
+const baseUrl = process.argv[2] || 'http://127.0.0.1:48721/mcp';
+
+const reqUrl = baseUrl;
+
+http.get(reqUrl, {
+    headers: { 'Accept': 'text/event-stream' }
+}, (res) => {
+    let buffer = '';
+    res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        
+        const lines = buffer.split('\n');
+        let endpoint = null;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].startsWith('event: endpoint') && lines[i+1] && lines[i+1].startsWith('data: ')) {
+                endpoint = lines[i+1].substring(6).trim();
+                break;
+            }
+            if (lines[i].includes('data: http') || lines[i].includes('data: /')) {
+                const match = lines[i].match(/data:\s*(\S+)/);
+                if (match && match[1].includes('message')) {
+                    endpoint = match[1];
+                    break;
+                }
+            }
+        }
+
+        if (endpoint) {
+            try {
+                const postUrl = endpoint.startsWith('http') ? new URL(endpoint) : new URL(endpoint, baseUrl);
+                
+                const req = http.request(postUrl, {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'}
+                }, (postRes) => {
+                    let body = '';
+                    postRes.on('data', d => body += d);
+                    postRes.on('end', () => {
+                        try {
+                            const json = JSON.parse(body);
+                            if (json.result && json.result.tools) {
+                                console.log(`SUCCESS: Found ${json.result.tools.length} tools`);
+                                console.log("TOOLS LIST:");
+                                json.result.tools.forEach(t => console.log(`- ${t.name}`));
+                            } else {
+                                console.log("Response:", body);
+                            }
+                        } catch (e) {
+                            console.log("Parse error:", e);
+                            console.log("Raw response:", body);
+                        }
+                        process.exit(0);
+                    });
+                });
+                
+                req.on('error', e => {
+                    console.log("POST error:", e);
+                    process.exit(1);
+                });
+
+                req.write(JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "tools/list"
+                }));
+                req.end();
+            } catch(e) {
+                console.log("Error constructing URL:", e);
+                process.exit(1);
+            }
+        }
+    });
+}).on('error', (e) => {
+    console.error("GET error:", e.message);
+});

package/scripts/debug/clear_graph.cjs

@@ -0,0 +1,12 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+const dbPath = path.join(__dirname, '..', '.code-intel', 'admin.db');
+const db = new Database(dbPath);
+try {
+  db.prepare('DELETE FROM graph_nodes').run();
+  db.prepare('DELETE FROM graph_edges').run();
+  console.log('Cleared ghost nodes from admin.db at', dbPath);
+} catch (err) {
+  console.error(err.message);
+}
+db.close();

package/scripts/debug/fetch_ticket.mjs

@@ -0,0 +1,18 @@
+// Usage: node fetch_ticket.mjs [baseUrl] [issueKey]
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+
+async function fetchTicket() {
+  const baseUrl = process.argv[2] || 'http://localhost:3061/mcp';
+  const issueKey = process.argv[3] || 'KSA-293';
+  const transport = new SSEClientTransport(new URL(`${baseUrl}?sessionId=test-${Date.now()}`));
+  const client = new Client({ name: 'test', version: '1.0' }, { capabilities: {} });
+  await client.connect(transport);
+  const result = await client.callTool({
+    name: 'jira_get_issue',
+    arguments: { issue_key: issueKey }
+  });
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(0);
+}
+fetchTicket().catch(console.error);

package/scripts/debug/get-jira.js

@@ -0,0 +1,27 @@
+// Usage: node get-jira.js [baseUrl] [issueKey]
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+
+async function main() {
+  const baseUrl = process.argv[2] || "http://localhost:3061/mcp";
+  const issueKey = process.argv[3] || "KSA-292";
+  console.log(`Fetching ${issueKey} from ${baseUrl}...`);
+  
+  const transport = new SSEClientTransport(new URL(`${baseUrl}?sessionId=test-session-${Date.now()}`));
+  const client = new Client({ name: "cli", version: "1.0.0" }, { capabilities: {} });
+  
+  try {
+    await client.connect(transport);
+    const result = await client.callTool({
+      name: "jira_get_issue",
+      arguments: { issue_key: issueKey }
+    });
+    console.log(JSON.stringify(result, null, 2));
+  } catch (err) {
+    console.error("Error:", err);
+  } finally {
+    await transport.close();
+  }
+}
+
+main();

package/scripts/debug/get_tools.js

@@ -0,0 +1,14 @@
+// Usage: node get-tools.js [baseUrl]
+const baseUrl = process.argv[2] || 'http://127.0.0.1:48721/mcp';
+
+async function check() {
+  try {
+    const r = await fetch(`${baseUrl}/tools/list`);
+    const d = await r.json();
+    console.log("Total tools:", d.tools.length);
+    console.log("List:", d.tools.map(t=>t.name).join(', '));
+  } catch (e) {
+    console.error("Error:", e.message);
+  }
+}
+check();

package/scripts/debug/inject_all_logs.js

@@ -0,0 +1,15 @@
+// Usage: node inject_all_logs.js [path-to-extension.js]
+const targetPath = process.argv[2] || 'C:\\Users\\ASUS\\.antigravity-ide\\extensions\\dnguyenminh.kiro-sdlc-agents-2.0.0\\out\\extension.js';
+
+const fs = require('fs');
+const content = fs.readFileSync(targetPath, 'utf8');
+
+let modified = content;
+
+modified = modified.replace(
+  /this\.outputChannel\.appendLine\((.*?)\)/g,
+  'this.outputChannel.appendLine($1); require("fs").appendFileSync("' + targetPath.replace('out\\extension.js', 'kiro_debug.log') + '", $1 + "\\n")'
+);
+
+fs.writeFileSync(targetPath, modified);
+console.log('Modified extension.js to mirror outputChannel to debug log');

package/scripts/debug/inject_debug.js

@@ -0,0 +1,14 @@
+// Usage: node inject_debug.js [path-to-extension.js]
+const targetPath = process.argv[2] || 'C:\\Users\\ASUS\\.antigravity-ide\\extensions\\dnguyenminh.kiro-sdlc-agents-2.0.0\\out\\extension.js';
+const fs = require('fs');
+
+const content = fs.readFileSync(targetPath, 'utf8');
+const logPath = targetPath.replace(/\\out\\extension\.js$/, '\\kiro_debug.log');
+
+const modified = content.replace(
+  'this.outputChannel.appendLine(`[MCP-InProcess] Server running in-process on port ${this._port} (PID: ${process.pid})`),this.updateMcpJson()',
+  'this.outputChannel.appendLine(`[MCP-InProcess] Server running in-process on port ${this._port} (PID: ${process.pid})`),this.updateMcpJson(); require("fs").appendFileSync("' + logPath + '", "SERVER STARTED ON " + this._port + "\\n");'
+);
+
+fs.writeFileSync(targetPath, modified);
+console.log('Modified extension.js to write debug logs');

package/scripts/debug/inject_error.js

@@ -0,0 +1,14 @@
+// Usage: node inject_error.js [path-to-extension.js]
+const targetPath = process.argv[2] || 'C:\\Users\\ASUS\\.antigravity-ide\\extensions\\dnguyenminh.kiro-sdlc-agents-2.0.0\\out\\extension.js';
+const fs = require('fs');
+
+const content = fs.readFileSync(targetPath, 'utf8');
+const logPath = targetPath.replace(/\\out\\extension\.js$/, '\\kiro_debug.log');
+
+const modified = content.replace(
+  'this.outputChannel.appendLine(`[MCP-InProcess] Failed to start: ${l}`),c}}',
+  'this.outputChannel.appendLine(`[MCP-InProcess] Failed to start: ${l}`); require("fs").appendFileSync("' + logPath + '", "ERROR: " + (c.stack || c) + "\\n"); throw c}}'
+);
+
+fs.writeFileSync(targetPath, modified);
+console.log('Modified extension.js to write errors to debug log');

package/scripts/debug/migrate-db-types.js

@@ -0,0 +1,91 @@
+import Database from 'better-sqlite3';
+import * as path from 'path';
+
+const DOCUMENT_TYPES = {
+    "BRD": "REQUIREMENT",
+    "FSD": "REQUIREMENT",
+    "TDD": "ARCHITECTURE",
+    "STP": "PROCEDURE",
+    "STC": "PROCEDURE",
+    "DPG": "PROCEDURE",
+    "RLN": "PROCEDURE",
+    "UG": "PROCEDURE",
+    "TEST-REPORT": "PROCEDURE",
+    "DISCREPANCY": "CONTEXT",
+    "SECURITY-REPORT": "PROCEDURE"
+};
+
+function tierForType(type) {
+  switch (type) { 
+    case 'REQUIREMENT': 
+    case 'ARCHITECTURE': 
+    case 'PROCEDURE': 
+    case 'API_DESIGN': 
+      return 'SEMANTIC'; 
+    case 'DECISION': 
+    case 'LESSON_LEARNED': 
+    case 'ERROR_PATTERN': 
+      return 'EPISODIC'; 
+    default: 
+      return 'WORKING'; 
+  }
+}
+
+const dbPath = path.join(__dirname, '..', '.code-intel', 'index.db');
+const db = new Database(dbPath);
+
+try {
+  // 1. De-duplicate entries
+  console.log('Running de-duplication...');
+  const initialCount = db.prepare('SELECT COUNT(*) as count FROM knowledge_entries').get().count;
+  
+  db.prepare(`
+    DELETE FROM knowledge_entries
+    WHERE id NOT IN (
+      SELECT MIN(id)
+      FROM knowledge_entries
+      GROUP BY COALESCE(source, ''), content
+    )
+  `).run();
+  
+  const midCount = db.prepare('SELECT COUNT(*) as count FROM knowledge_entries').get().count;
+  console.log(`De-duplicated: ${initialCount} -> ${midCount} entries (removed ${initialCount - midCount} duplicates)`);
+
+  // 2. Classify and update type & tier
+  console.log('Classifying and updating types...');
+  const rows = db.prepare('SELECT id, source FROM knowledge_entries WHERE source IS NOT NULL').all();
+  
+  let updatedCount = 0;
+  
+  const updateStmt = db.prepare('UPDATE knowledge_entries SET type = ?, tier = ? WHERE id = ?');
+  const updateMany = db.transaction((entries) => {
+    for (const entry of entries) {
+      const source = entry.source;
+      const ext = path.extname(source).toLowerCase();
+      const baseName = path.basename(source, ext).toUpperCase();
+      let docType = "CONTEXT";
+      for (const key of Object.keys(DOCUMENT_TYPES)) {
+        if (baseName === key || baseName.startsWith(key + "-") || baseName.startsWith(key + "_") || baseName.startsWith(key)) {
+          docType = DOCUMENT_TYPES[key];
+          break;
+        }
+      }
+      
+      const tier = tierForType(docType);
+      updateStmt.run(docType, tier, entry.id);
+      updatedCount++;
+    }
+  });
+
+  updateMany(rows);
+  console.log(`Updated ${updatedCount} entries with correct type and tier.`);
+
+  const finalDistribution = db.prepare('SELECT type, COUNT(*) as count FROM knowledge_entries GROUP BY type').all();
+  console.log('Final type distribution:');
+  console.log(finalDistribution);
+  
+} catch (err) {
+  console.error('Migration failed:', err);
+} finally {
+  db.close();
+}

package/scripts/debug/read-ksa-295.mjs

@@ -0,0 +1,15 @@
+// Usage: node read-ksa-295.mjs [baseUrl]
+const baseUrl = process.argv[2] || 'http://127.0.0.1:48721/mcp';
+
+async function main() {
+  try {
+    const res = await fetch(`${baseUrl}/tools/list`, {
+      method: 'GET',
+    });
+    const result = await res.json();
+    console.log(JSON.stringify(result.tools.map(t => t.name), null, 2));
+  } catch (err) {
+    console.error('Fetch error:', err.message);
+  }
+}
+main();

package/scripts/debug/scratch.cjs

@@ -0,0 +1,17 @@
+const Database = require('better-sqlite3');
+const db = new Database('./.code-intel/index.db', { readonly: true });
+try {
+  const duplicates = db.prepare(`
+    SELECT source, COUNT(*) as count 
+    FROM knowledge_entries 
+    WHERE source IS NOT NULL 
+    GROUP BY source 
+    HAVING count > 10
+    LIMIT 20
+  `).all();
+  console.log('Duplicates:');
+  console.log(duplicates);
+} catch (err) {
+  console.error(err.message);
+}
+db.close();

package/scripts/debug/scratch_admin.cjs

@@ -0,0 +1,11 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+const dbPath = path.join(__dirname, '..', '.code-intel', 'admin.db');
+const db = new Database(dbPath, { readonly: true });
+try {
+  const row = db.prepare('SELECT COUNT(*) as count FROM graph_nodes').get();
+  console.log('graph_nodes count in admin.db:', row.count);
+} catch (err) {
+  console.error(err.message);
+}
+db.close();

package/scripts/debug/sm-discovery.mjs

@@ -0,0 +1,33 @@
+// Usage: node sm-discovery.mjs [baseUrl] [query]
+const baseUrl = process.argv[2] || 'http://localhost:48721/mcp';
+const query = process.argv[3] || 'search issues';
+
+async function discover(query) {
+  const res = await fetch(`${baseUrl}/tools/call`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      tool_name: 'find_tools',
+      arguments: { query, top_k: 5, threshold: 0.4 }
+    })
+  });
+  const data = await res.json();
+  if (data.isError) return [];
+  const parsed = JSON.parse(data.content[0].text);
+  return parsed.tools.map(t => t.name);
+}
+
+async function main() {
+  const queries = [
+    process.argv[3] || "get issue details from project tracker",
+    "search knowledge base semantic",
+    "convert markdown to docx word document"
+  ];
+  
+  for (const q of queries) {
+    const tools = await discover(q);
+    console.log(`Query: "${q}" ->`, tools);
+  }
+}
+
+main().catch(console.error);

package/scripts/debug/test-atlassian-endpoints.js

@@ -0,0 +1,32 @@
+import http from 'http';
+
+// Usage: node test-atlassian-endpoints.js [baseUrl]
+const baseUrl = process.argv[2] || 'http://localhost:3061/mcp';
+
+const endpoints = [
+  `${baseUrl}?sessionId=test`
+];
+
+async function checkEndpoint(url) {
+  return new Promise((resolve) => {
+    http.get(url, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        resolve({ url, status: res.statusCode, contentType: res.headers['content-type'], body: data });
+      });
+    }).on('error', (err) => {
+      resolve({ url, error: err.message });
+    });
+  });
+}
+
+async function main() {
+  console.log('Testing Atlassian endpoints...');
+  for (const url of endpoints) {
+    const result = await checkEndpoint(url);
+    console.log(JSON.stringify(result));
+  }
+}
+
+main();

package/scripts/debug/test-convert.js

@@ -0,0 +1,33 @@
+import http from 'http';
+
+// Usage: node test-convert.js [baseUrl]
+const baseUrl = process.argv[2] || 'http://localhost:48721/mcp';
+
+const payload = JSON.stringify({
+  tool_name: 'execute_dynamic_tool',
+  arguments: {
+    toolName: 'convert_to_markdown',
+    arguments: {
+      uri: 'file:///C:/projects/kiro/FEC_CR_Builder/documents/KSA-14/STC-v1-KSA-14.xlsx'
+    }
+  }
+});
+
+const req = http.request(`${baseUrl}/tools/call`, {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(payload)
+  }
+}, (res) => {
+  let data = '';
+  res.on('data', chunk => data += chunk);
+  res.on('end', () => {
+    console.log(`Status: ${res.statusCode}`);
+    console.log(`Body: ${data}`);
+  });
+});
+
+req.on('error', (err) => console.error(err));
+req.write(payload);
+req.end();

package/scripts/debug/test-db-debug.cjs

@@ -0,0 +1,24 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+
+// Usage: node test-db-debug.js [db-path]
+// Defaults to .code-intel/index-backend.db relative to repo root.
+const repoRoot = path.resolve(__dirname, '..', '..');
+const dbPath = path.resolve(process.argv[2] || path.join(repoRoot, '.code-intel', 'index-backend.db'));
+
+console.log('DB Path:', dbPath);
+const db = new Database(dbPath, { readonly: true });
+
+const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+console.log('Tables:', tables.map(t => t.name));
+
+for (const table of tables) {
+  try {
+    const count = db.prepare(`SELECT count(*) as count FROM ${table.name}`).get();
+    console.log(`Table ${table.name}: ${count.count} rows`);
+  } catch (err) {
+    console.error(`Error querying ${table.name}:`, err.message);
+  }
+}
+
+db.close();

package/scripts/debug/test-db.js

@@ -0,0 +1,22 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+
+const repoRoot = path.resolve(__dirname, '..', '..');
+const dbPath = path.join(repoRoot, '.code-intel', 'index.db');
+
+console.log('Querying index.db at:', dbPath);
+const db = new Database(dbPath);
+
+const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+console.log('Tables:', tables.map(t => t.name));
+
+for (const table of tables) {
+  try {
+    const count = db.prepare(`SELECT count(*) as count FROM ${table.name}`).get();
+    console.log(`Table ${table.name}: ${count.count} rows`);
+  } catch (err) {
+    console.error(`Error querying ${table.name}:`, err.message);
+  }
+}
+
+db.close();