@mrpatronz/nexusflow 0.1.4 → 0.1.6

package/src/mcp/server.ts

@@ -66,6 +66,42 @@ export async function startMcpServer(workspacePath?: string) {
             required: ['serviceName'],
           },
         },
+        {
+          name: 'get_workspace_graph',
+          description: 'Retrieve the structural architecture graph of the NexusFlow workspace. Contains nodes for repos, packages, API endpoints, and exposed ports, plus relation edges (CONTAINS, DEPENDS_ON, EXPOSES, CALLS). Highly token-efficient for global workspace context.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              workspaceId: {
+                type: 'string',
+                description: 'Optional ID/branchName of the workspace. If omitted, uses the currently active workspace.',
+              },
+            },
+          },
+        },
+        {
+          name: 'query_workspace_graph',
+          description: 'Query the workspace architecture graph by filtering nodes or edges (e.g., node types like "repo", "package", "endpoint", "port", or edge types like "DEPENDS_ON", "EXPOSES", "CALLS"). Reduces token payload by fetching specific architectural paths.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              nodeType: {
+                type: 'string',
+                enum: ['repo', 'package', 'endpoint', 'port'],
+                description: 'Optional node type to filter.',
+              },
+              edgeType: {
+                type: 'string',
+                enum: ['DEPENDS_ON', 'EXPOSES', 'CALLS'],
+                description: 'Optional edge/relation type to filter.',
+              },
+              workspaceId: {
+                type: 'string',
+                description: 'Optional ID/branchName of the workspace. If omitted, uses the currently active workspace.',
+              },
+            },
+          },
+        },
       ],
     };
   });
@@ -179,6 +215,101 @@ export async function startMcpServer(workspacePath?: string) {
       }
     }
 
+    if (name === 'get_workspace_graph') {
+      try {
+        const graphPath = path.join(resolvedWorkspacePath, 'nexusflow-graph.json');
+        
+        try {
+          await fs.access(graphPath);
+        } catch {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `Workspace graph file not found at ${graphPath}. Run "nexusflow sync" or rebuild the workspace to generate it.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const content = await fs.readFile(graphPath, 'utf8');
+        return {
+          content: [
+            {
+              type: 'text',
+              text: content,
+            },
+          ],
+        };
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error reading workspace graph: ${error.message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+
+    if (name === 'query_workspace_graph') {
+      const nodeType = (args as any).nodeType;
+      const edgeType = (args as any).edgeType;
+
+      try {
+        const graphPath = path.join(resolvedWorkspacePath, 'nexusflow-graph.json');
+        
+        try {
+          await fs.access(graphPath);
+        } catch {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `Workspace graph file not found at ${graphPath}. Run "nexusflow sync" or rebuild the workspace to generate it.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const content = await fs.readFile(graphPath, 'utf8');
+        const graph = JSON.parse(content);
+
+        let nodes = graph.nodes;
+        let edges = graph.edges;
+
+        if (nodeType) {
+          nodes = nodes.filter((n: any) => n.type === nodeType);
+        }
+        if (edgeType) {
+          edges = edges.filter((e: any) => e.type === edgeType);
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ nodes, edges }, null, 2),
+            },
+          ],
+        };
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error querying workspace graph: ${error.message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+
     throw new Error(`Tool not found: ${name}`);
   });
 

package/src/server.ts

@@ -17,6 +17,7 @@ import { scanForRepos } from './core/scanner.js';
 import { createWorkspace, listWorkspaces, loadFeatureConfig } from './core/workspace.js';
 import { analyzeAllRepos } from './analyzers/index.js';
 import { generateContextFiles } from './generators/index.js';
+import { packWorkspace } from './core/packer.js';
 import { detectAIAssistants } from './utils/detect-ai.js';
 import { detectEditors } from './utils/detect-editors.js';
 import { findSessions, getSessionTranscript } from './utils/session-finder.js';
@@ -606,6 +607,30 @@ app.get('/api/update-status', async (c) => {
   }
 });
 
+// 18. Pack workspace codebase and download
+app.get('/api/workspace/:id/pack', async (c) => {
+  try {
+    const id = decodeURIComponent(c.req.param('id'));
+    const config = await loadConfig();
+    const workspacePath = path.join(config.workspacesDir, id);
+
+    const feature = await loadFeatureConfig(workspacePath);
+    if (!feature) {
+      return c.json({ error: 'Workspace configuration not found.' }, 404);
+    }
+
+    const result = await packWorkspace(workspacePath);
+    const content = await fs.readFile(result.outputPath, 'utf-8');
+
+    c.header('Content-Disposition', `attachment; filename="nexusflow-context-${id.replace(/[\/\\ ]/g, '-')}.xml"`);
+    c.header('Content-Type', 'application/xml');
+    return c.text(content);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
 // Serve index.html explicitly on root endpoint
 app.get('/', async (c) => {
   try {

package/src/utils/update-check.ts

@@ -39,7 +39,7 @@ export function getCurrentVersion(): string {
   } catch {
     // Fallback if filesystem access fails
   }
-  return '0.1.3'; // Sensible fallback (active release)
+  return '0.1.5'; // Sensible fallback (active release)
 }
 
 /**