vectorforce 0.3.3 → 0.3.7

package/src/mcp/mcp-server.js

@@ -1,6 +1,34 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { ErrorCode, VectorForceError } from '../core/errors.js';
 
-export const MCP_PROTOCOL_VERSION = '2024-11-05';
+export const MCP_PROTOCOL_VERSION = '2025-11-25';
+
+export const MCP_SUPPORTED_PROTOCOL_VERSIONS = [
+  '2025-11-25',
+  '2025-06-18',
+  '2025-03-26',
+  '2024-11-05'
+];
+
+function readServerVersion() {
+  try {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version || '0.3.2';
+  } catch {
+    return '0.3.2';
+  }
+}
+
+export const MCP_SERVER_VERSION = readServerVersion();
+
+export function negotiateProtocolVersion(clientVersion) {
+  if (clientVersion && MCP_SUPPORTED_PROTOCOL_VERSIONS.includes(clientVersion)) {
+    return clientVersion;
+  }
+  return MCP_PROTOCOL_VERSION;
+}
 
 export const MCP_TOOLS = [
   {
@@ -214,14 +242,31 @@ export class McpServer {
       return;
     }
 
+    // JSON-RPC batch: dispatch each entry; entries without an id are notifications.
+    if (Array.isArray(req)) {
+      if (req.length === 0) {
+        this._sendError(null, -32600, 'Invalid Request: empty batch');
+        return;
+      }
+      for (const sub of req) {
+        this._dispatch(sub);
+      }
+      return;
+    }
+
+    this._dispatch(req);
+  }
+
+  _dispatch(req) {
+    if (!req || typeof req !== 'object' || Array.isArray(req)) {
+      this._sendError(null, -32600, 'Invalid Request');
+      return;
+    }
+
     const { id, method, params } = req;
 
-    // Notifications (no id)
+    // Notifications (no id) are acknowledged silently, never answered.
     if (id === undefined || id === null) {
-      if (method === 'notifications/initialized') {
-        // Client handshake complete
-        return;
-      }
       return;
     }
 
@@ -229,15 +274,17 @@ export class McpServer {
       switch (method) {
         case 'initialize': {
           this._sendResult(id, {
-            protocolVersion: MCP_PROTOCOL_VERSION,
+            protocolVersion: negotiateProtocolVersion(params?.protocolVersion),
             serverInfo: {
               name: 'vectorforce',
-              version: '0.1.0'
+              version: MCP_SERVER_VERSION
             },
             capabilities: {
               tools: {
                 listChanged: false
-              }
+              },
+              resources: {},
+              prompts: {}
             }
           });
           break;
@@ -255,6 +302,31 @@ export class McpServer {
           break;
         }
 
+        case 'resources/list': {
+          this._sendResult(id, { resources: [] });
+          break;
+        }
+
+        case 'resources/templates/list': {
+          this._sendResult(id, { resourceTemplates: [] });
+          break;
+        }
+
+        case 'resources/read': {
+          this._sendError(id, -32602, `Unknown resource: ${params?.uri || '(missing uri)'}`);
+          break;
+        }
+
+        case 'prompts/list': {
+          this._sendResult(id, { prompts: [] });
+          break;
+        }
+
+        case 'prompts/get': {
+          this._sendError(id, -32602, `Unknown prompt: ${params?.name || '(missing name)'}`);
+          break;
+        }
+
         case 'tools/call': {
           this._handleToolCall(id, params);
           break;

package/src/operations/project-service.js

@@ -1,6 +1,7 @@
 import { Authorizer } from '../policy/authorizer.js';
 import { sha256 } from '../core/hash.js';
 import { basename, dirname } from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { ErrorCode, VectorForceError } from '../core/errors.js';
 
 export class ProjectService {
@@ -13,6 +14,8 @@ export class ProjectService {
 
   /**
    * Initialize or retrieve a project for a workspace directory.
+   * Derives a deterministic project identity from Git remote URL if present,
+   * ensuring that multiple developers cloning the same repo share the identical project ID.
    * @param {string} workspacePath
    * @param {string} [customName]
    * @returns {{ project_id: string, canonical_path: string, name: string, created_at: string }}
@@ -23,7 +26,21 @@ export class ProjectService {
     if (existing) {
       return existing;
     }
-    const idHash = sha256(canonical).slice(0, 16);
+
+    let identitySeed = canonical;
+    try {
+      const gitRemote = execFileSync('git', ['config', '--get', 'remote.origin.url'], {
+        cwd: canonical,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 1000
+      }).trim();
+      if (gitRemote) {
+        identitySeed = gitRemote.toLowerCase();
+      }
+    } catch {}
+
+    const idHash = sha256(identitySeed).slice(0, 16);
     const projectId = `proj-${idHash}`;
     const name = customName || basename(canonical);
     return this.store.registerProject(projectId, canonical, name);

package/src/studio/server.js

@@ -13,6 +13,7 @@ import { ReasoningService } from '../operations/reasoning-service.js';
 import { CodeIndexProvider } from '../providers/code-index-provider.js';
 import { LlmProvider, resolveLlmConfig } from '../providers/llm-provider.js';
 import { GitProvider } from '../providers/git-provider.js';
+import { DocumentProvider } from '../providers/document-provider.js';
 import { HarnessConfig } from '../mcp/harness-config.js';
 
 export function createStudioServer({
@@ -136,7 +137,7 @@ export function createStudioServer({
         const allConstraints = new Set();
 
         for (const cp of checkpoints) {
-          if (cp.claims.decisions) {
+          if (cp.claims?.decisions) {
             for (const d of cp.claims.decisions) {
               if (!seenDecisions.has(d.id)) {
                 seenDecisions.add(d.id);
@@ -144,18 +145,58 @@ export function createStudioServer({
               }
             }
           }
-          if (cp.claims.constraints) {
+          if (cp.claims?.constraints) {
             for (const c of cp.claims.constraints) {
               allConstraints.add(c);
             }
           }
         }
 
+        // Collect allowlisted docs details (sizes, hashes) safely
+        let docDetails = [];
+        try {
+          const collected = DocumentProvider.collect(workspacePath, allowedDocs, allowedDocs);
+          docDetails = (collected.documents || []).map(d => ({
+            path: d.relative_path,
+            size: d.size_bytes ? (d.size_bytes < 1024 ? `${d.size_bytes} B` : `${(d.size_bytes / 1024).toFixed(1)} kB`) : '0 B',
+            hash: d.sha256_hash ? d.sha256_hash.slice(0, 10) + '...' : 'tracked',
+            status: 'Verified'
+          }));
+          for (const g of (collected.gaps || [])) {
+            docDetails.push({
+              path: g.relative_path,
+              size: 'Missing',
+              hash: 'N/A',
+              status: 'File Missing'
+            });
+          }
+        } catch {
+          docDetails = (allowedDocs || []).map(p => ({ path: p, size: 'Tracked', hash: 'allowlisted', status: 'Verified' }));
+        }
+
+        // Extract real top AST symbols from code index
+        const topSymbols = [];
+        for (const f of codeIndex.files) {
+          if (f.symbols) {
+            for (const c of (f.symbols.classes || [])) {
+              topSymbols.push({ name: c, type: 'Class', file: f.path });
+            }
+            for (const fn of (f.symbols.functions || [])) {
+              topSymbols.push({ name: fn, type: 'Function', file: f.path });
+            }
+            for (const exp of (f.symbols.exports || [])) {
+              topSymbols.push({ name: exp, type: 'Export', file: f.path });
+            }
+          }
+        }
+
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
           filesIndexed: codeIndex.files.length,
           symbolsIndexed: codeIndex.files.reduce((acc, f) => acc + ((f.symbols?.functions?.length || 0) + (f.symbols?.classes?.length || 0) + (f.symbols?.exports?.length || 0)), 0),
           allowedDocuments: allowedDocs,
+          allowedDocsList: docDetails,
+          topSymbols: topSymbols.slice(0, 30),
           decisions: allDecisions,
           constraints: Array.from(allConstraints),
           totalCheckpoints: checkpoints.length
@@ -188,6 +229,12 @@ export function createStudioServer({
         const codeIndex = CodeIndexProvider.build(workspacePath);
         const checkpoints = store.getCheckpoints(project.project_id);
         const changedFiles = new Set(GitProvider.collectChangedFiles(workspacePath).files || []);
+        const requestedTaskId = url.searchParams.get('taskId') || null;
+
+        // If a task is selected, get its allowlisted docs or touched files
+        const taskCheckpoints = requestedTaskId
+          ? checkpoints.filter(cp => cp.task_id === requestedTaskId)
+          : checkpoints;
 
         // Dynamically cluster code files by architectural module
         const moduleMap = new Map();
@@ -207,7 +254,7 @@ export function createStudioServer({
           } else if (file.path.startsWith('bin/')) {
             modId = 'cli';
           } else {
-            modId = 'project-root';
+            modId = parts.length > 1 ? parts[0] : 'root';
           }
 
           if (!moduleMap.has(modId)) {
@@ -221,15 +268,26 @@ export function createStudioServer({
               'core': 'Core Hashes & Errors',
               'cli': 'Unified CLI Interface',
               'studio-ui': 'React Studio Frontend',
-              'tests': 'Automated Test Suite (62 Tests)',
-              'wiki': 'Architecture Wiki (ADR 001-014)',
-              'project-root': 'Project Root & Config'
+              'tests': 'Automated Test Suite',
+              'wiki': 'Architecture Wiki',
+              'root': 'Project Root & Config',
+              'backend': 'Backend Services',
+              'frontend': 'Frontend Application',
+              'api': 'API Routes & Handlers',
+              'models': 'Data Models & Schemas',
+              'controllers': 'Controllers',
+              'routes': 'Router Layer',
+              'services': 'Domain Services',
+              'utils': 'Utility Helpers'
             };
+            const capitalizedMod = modId.charAt(0).toUpperCase() + modId.slice(1);
             moduleMap.set(modId, {
               id: modId,
-              name: prettyNames[modId] || modId.toUpperCase(),
-              category: (modId === 'policy' || modId === 'storage') ? 'Security & Data' : modId === 'providers' ? 'AI / LLM' : modId === 'mcp' ? 'Integration' : modId === 'wiki' ? 'Governance' : 'Core',
-              owner: 'VectorForce',
+              name: prettyNames[modId] || capitalizedMod,
+              category: (modId === 'policy' || modId === 'storage' || modId === 'auth' || modId === 'security') ? 'Security' :
+                        (modId === 'providers' || modId === 'ai' || modId === 'llm') ? 'AI / Copilot' :
+                        (modId === 'mcp' || modId === 'api' || modId === 'routes') ? 'Integration' : 'Core',
+              owner: project.name || 'Workspace',
               files: [],
               drift: false,
               dependencies: new Set(),
@@ -259,23 +317,51 @@ export function createStudioServer({
 
         // Link real ADR decisions from checkpoints
         const allDecisions = [];
-        for (const cp of checkpoints) {
+        for (const cp of taskCheckpoints) {
           if (cp.claims?.decisions) {
             for (const d of cp.claims.decisions) {
-              allDecisions.push(`${d.id}: ${d.title}`);
+              allDecisions.push(`${d.id}: ${d.title || d.rationale || ''}`);
             }
           }
         }
 
-        const modules = Array.from(moduleMap.values()).map(m => ({
-          ...m,
-          status: m.drift ? 'Drift Detected' : 'Verified',
-          dependencies: Array.from(m.dependencies),
-          decisions: allDecisions.slice(0, 3)
-        }));
+        // Compute clean 2D grid coordinates for modules
+        const modArray = Array.from(moduleMap.values());
+        const cols = Math.min(3, Math.max(2, Math.ceil(Math.sqrt(modArray.length))));
+        const colWidth = 270;
+        const rowHeight = 160;
+        const startX = 40;
+        const startY = 40;
+
+        const connections = [];
+        for (const [fromMod, mod] of moduleMap.entries()) {
+          for (const toMod of mod.dependencies) {
+            connections.push({ from: fromMod, to: toMod });
+          }
+        }
+
+        const modules = modArray.map((m, idx) => {
+          const col = idx % cols;
+          const row = Math.floor(idx / cols);
+          return {
+            ...m,
+            x: startX + col * colWidth,
+            y: startY + row * rowHeight,
+            status: m.drift ? 'Drift Detected' : 'Verified',
+            dependencies: Array.from(m.dependencies),
+            decisions: allDecisions.slice(0, 3),
+            files: m.files.length,
+            description: `${m.files.length} file${m.files.length === 1 ? '' : 's'} · ${m.symbolsCount} symbols indexed.`
+          };
+        });
 
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ modules }));
+        res.end(JSON.stringify({
+          modules,
+          connections,
+          activeTask: requestedTaskId,
+          totalFiles: codeIndex.files.length
+        }));
         return;
       }