@ismaelsoilet/synapsejs 1.8.0 → 1.11.1

package/src/mcp/server.ts

@@ -28,11 +28,38 @@ import { machineContract } from '../compiler/contract';
 import { analyzeImpact } from '../compiler/impact-analyzer';
 import { rollbackSliceMigrations, runSliceMigrations } from '../compiler/migration-runner';
 import { runSliceOracles } from '../compiler/oracle-runner';
-import { type SliceTemplate, scaffoldCrud, scaffoldSlice } from '../compiler/scaffolder';
+import { type SliceTemplate, scaffoldCrud, scaffoldDomain, scaffoldSlice } from '../compiler/scaffolder';
 import { checkSchemaDrift } from '../compiler/schema-drift';
 import { findSliceFiles, resolveSlicesDir } from '../compiler/slice-discovery';
 import { artifactDirectory, splitSlice, verifySplit, writeSplitArtifacts } from '../compiler/slice-splitter';
+import { validatePathSegment } from '../core/path-guard';
 import { SYNAPSE_VERSION } from '../version';
+import { MCP_TOOLS } from './tools';
+
+/**
+ * Caps a tool payload so a broken workspace cannot flood the caller's context, and
+ * makes every path relative to the project root so a tool result carries no absolute
+ * filesystem location.
+ */
+const MCP_MAX_ITEMS = 100;
+
+export function capItems<T>(items: T[]): { items: T[]; truncated: boolean; total: number } {
+  return {
+    items: items.slice(0, MCP_MAX_ITEMS),
+    truncated: items.length > MCP_MAX_ITEMS,
+    total: items.length
+  };
+}
+
+export function toRelativePath(root: string, value: unknown): unknown {
+  if (typeof value !== 'string' || !path.isAbsolute(value)) {
+    return value;
+  }
+
+  const relative = path.relative(root, value);
+
+  return relative.startsWith('..') ? path.basename(value) : relative;
+}
 
 interface JsonRpcRequest {
   jsonrpc: string;
@@ -110,220 +137,7 @@ export class SynapseMcpServer {
           jsonrpc: '2.0',
           id,
           result: {
-            tools: [
-              {
-                name: 'synapse_get_repo_map',
-                description:
-                  'Get compressed codebase skeleton map (.codebase/repo-map.d.ts) for AI context (<3000 tokens)',
-                inputSchema: { type: 'object', properties: {} }
-              },
-              {
-                name: 'synapse_get_db_schema',
-                description:
-                  'Get the centralized database schema catalog (.codebase/db-schema.d.ts) for AI context and type-safe relational queries',
-                inputSchema: { type: 'object', properties: {} }
-              },
-              {
-                name: 'synapse_check',
-                description:
-                  'Run machine-centric compiler diagnostics, returning exact JSON coordinates (file, line, col, message)',
-                inputSchema: {
-                  type: 'object',
-                  properties: {
-                    targetFile: { type: 'string', description: 'Optional specific file to check' }
-                  }
-                }
-              },
-              {
-                name: 'synapse_split',
-                description:
-                  'Run slice splitter and leak verification gates to enforce server/client isolation and zero leakage',
-                inputSchema: {
-                  type: 'object',
-                  properties: {
-                    targetSlice: { type: 'string', description: 'Optional specific slice name to split' }
-                  }
-                }
-              },
-              {
-                name: 'synapse_run_pbt',
-                description: 'Execute Fast-Check Property-Based Testing (PBT) invariant test suite across all slices',
-                inputSchema: { type: 'object', properties: {} }
-              },
-              {
-                name: 'synapse_scaffold_slice',
-                description:
-                  'Scaffold a new fullstack atomic vertical slice with TypeBox, Result, Action, React UI, and PBT oracles',
-                inputSchema: {
-                  type: 'object',
-                  required: ['domain', 'name'],
-                  properties: {
-                    domain: { type: 'string', description: 'Domain name (e.g. billing, customers, orders)' },
-                    name: { type: 'string', description: 'Slice name in kebab-case (e.g. cancel-subscription)' },
-                    template: {
-                      type: 'string',
-                      enum: ['create', 'list', 'update', 'delete', 'login', 'oauth-github', 'crud'],
-                      description: 'Optional slice template shape (default: create)'
-                    },
-                    fields: {
-                      type: 'string',
-                      description:
-                        'Optional fields grammar, e.g. "name:string,email:string,status:enum(ACTIVE|INACTIVE),price:number"'
-                    }
-                  }
-                }
-              },
-              {
-                name: 'synapse_contract',
-                description:
-                  'Return the machine contract: slice exports and suffixes, Result and HTTP semantics, session rules, addressing, SSR behavior and the gates to run',
-                inputSchema: { type: 'object', properties: {} }
-              },
-              {
-                name: 'synapse_migrate',
-                description:
-                  'Auto-discover and apply sliceSchema DDL declarations across slices into the active database',
-                inputSchema: { type: 'object', properties: {} }
-              },
-              {
-                name: 'synapse_check_db_drift',
-                description:
-                  'Inspects live database catalog against sliceSchema DDL contracts, identifying missing tables, missing columns, and orphan tables',
-                inputSchema: { type: 'object', properties: {} }
-              },
-              {
-                name: 'synapse_diff_impact',
-                description:
-                  'Analyzes cross-slice dependencies (Foreign Keys, shared module imports, and table references) to report all slices impacted by a file or table change',
-                inputSchema: {
-                  type: 'object',
-                  required: ['target'],
-                  properties: {
-                    target: {
-                      type: 'string',
-                      description: 'Slice file path, slice name, shared module path, or table name'
-                    }
-                  }
-                }
-              },
-              {
-                name: 'synapse_rollback',
-                description: 'Roll back applied sliceSchema migrations by executing their -- down: statements',
-                inputSchema: {
-                  type: 'object',
-                  properties: {
-                    targetSlice: { type: 'string', description: 'Optional target slice to rollback' },
-                    steps: { type: 'number', description: 'Number of recent migrations to rollback (default: 1)' }
-                  }
-                }
-              },
-              {
-                name: 'synapse_test_gate',
-                description:
-                  'Execute Fast-Check PBT oracles and immediately triage failures with Jev System One semantic test-gate to prevent LLM token waste',
-                inputSchema: {
-                  type: 'object',
-                  properties: {}
-                }
-              },
-              {
-                name: 'synapse_abort_check',
-                description:
-                  'Evaluate plan and error history with Jev System One to detect doomed trajectories, circular loops, or high-risk refactor dead ends',
-                inputSchema: {
-                  type: 'object',
-                  required: ['plan', 'history'],
-                  properties: {
-                    plan: { type: 'string', description: 'Proposed implementation plan or architectural change' },
-                    history: { type: 'string', description: 'Recent attempt history, error logs, or failure reasons' }
-                  }
-                }
-              },
-              {
-                name: 'synapse_verify_completion',
-                description:
-                  'Verify slice implementation and test outputs against acceptance criteria using Jev System One before committing work',
-                inputSchema: {
-                  type: 'object',
-                  required: ['criteria', 'output'],
-                  properties: {
-                    criteria: { type: 'string', description: 'Acceptance criteria or requirement specifications' },
-                    output: {
-                      type: 'string',
-                      description: 'Actual implementation summary, test output, or slice behavior'
-                    }
-                  }
-                }
-              },
-              {
-                name: 'synapse_reasoning_effort',
-                description:
-                  'Dynamically modulate agent reasoning effort (Astra-Jev) to low/medium/high based on step context (lowering effort for mechanical commands like split/migrate/skeleton)',
-                inputSchema: {
-                  type: 'object',
-                  required: ['context'],
-                  properties: {
-                    context: {
-                      type: 'string',
-                      description: 'Immediate command or task context, e.g. "synapse split", "git commit"'
-                    },
-                    provider: {
-                      type: 'string',
-                      description: 'Target LLM provider, e.g. "deepseek", "anthropic", "openai"'
-                    },
-                    sessionContextTokens: {
-                      type: 'number',
-                      description: 'Estimated session context token count to protect prompt cache'
-                    }
-                  }
-                }
-              },
-              {
-                name: 'synapse_triage_error',
-                description:
-                  'Triage an arbitrary test failure or execution error log using Jev System One to classify root causes (env_missing vs flaky_transient vs deep_logic) and avoid token waste',
-                inputSchema: {
-                  type: 'object',
-                  required: ['failureLog'],
-                  properties: {
-                    failureLog: {
-                      type: 'string',
-                      description: 'Error log, stack trace or terminal output to triage'
-                    }
-                  }
-                }
-              },
-              {
-                name: 'synapse_route_task',
-                description:
-                  'Semantically route a development task to the optimal model/reasoning tier via Jev System One',
-                inputSchema: {
-                  type: 'object',
-                  required: ['task'],
-                  properties: {
-                    task: {
-                      type: 'string',
-                      description: 'Description of the coding, refactoring, or diagnostic task'
-                    }
-                  }
-                }
-              },
-              {
-                name: 'synapse_evaluate_nudge',
-                description:
-                  'Evaluate whether an agent is prematurely stopping or needs a proactive nudge to continue verification',
-                inputSchema: {
-                  type: 'object',
-                  required: ['transcriptTail'],
-                  properties: {
-                    transcriptTail: {
-                      type: 'string',
-                      description: 'Recent transcript steps or conversation history tail'
-                    }
-                  }
-                }
-              }
-            ]
+            tools: MCP_TOOLS
           }
         };
       }
@@ -405,7 +219,22 @@ export class SynapseMcpServer {
             );
           } else if (toolName === 'synapse_check') {
             const report = runMachineVerifications(this.root, args.targetFile);
-            contentText = JSON.stringify(report, null, 2);
+            const issues = capItems(report.issues).items.map((issue) => ({
+              ...issue,
+              file: toRelativePath(this.root, issue.file)
+            }));
+
+            contentText = JSON.stringify(
+              {
+                ...report,
+                issues,
+                issuesTruncated: report.issues.length > MCP_MAX_ITEMS,
+                reportedIssues: issues.length,
+                totalIssues: report.issues.length
+              },
+              null,
+              2
+            );
           } else if (toolName === 'synapse_split') {
             const resolution = resolveSlicesDir(this.root);
             if (!resolution.ok) {
@@ -475,13 +304,15 @@ export class SynapseMcpServer {
             }
 
             const splitStatus = failed || slices.length === 0 ? 'FAIL' : 'PASS';
+            const boundedSlices = capItems(slices);
             contentText = JSON.stringify(
               {
                 status: splitStatus,
                 operation: 'SLICE_SPLIT',
                 slicesDir: path.relative(this.root, resolution.value.slicesDir),
                 totalProcessed: slices.length,
-                slices
+                slicesTruncated: boundedSlices.truncated,
+                slices: boundedSlices.items
               },
               null,
               2
@@ -584,6 +415,42 @@ export class SynapseMcpServer {
                 2
               );
             }
+          } else if (toolName === 'synapse_scaffold_domain') {
+            const domainRes = scaffoldDomain(args.domain, this.root, args.fields);
+            if (!domainRes.ok) {
+              return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                  isError: true,
+                  content: [
+                    {
+                      type: 'text',
+                      text: JSON.stringify(
+                        {
+                          status: 'FAIL',
+                          code: domainRes.error.code,
+                          message: domainRes.error.message,
+                          candidates: domainRes.error.candidates
+                        },
+                        null,
+                        2
+                      )
+                    }
+                  ]
+                }
+              };
+            }
+
+            contentText = JSON.stringify(
+              {
+                status: 'PASS',
+                domain: args.domain,
+                createdFiles: domainRes.value.map((f) => path.relative(this.root, f))
+              },
+              null,
+              2
+            );
           } else if (toolName === 'synapse_contract') {
             contentText = JSON.stringify(machineContract(), null, 2);
           } else if (toolName === 'synapse_migrate') {
@@ -617,7 +484,20 @@ export class SynapseMcpServer {
               };
             }
             const report = analyzeImpact(args.target, this.root);
-            contentText = JSON.stringify(report, null, 2);
+            const bounded = capItems(report.impactedSlices);
+            contentText = JSON.stringify(
+              {
+                ...report,
+                impactedSlices: bounded.items.map((slice) => ({
+                  ...slice,
+                  filePath: toRelativePath(this.root, slice.filePath)
+                })),
+                impactedTruncated: bounded.truncated,
+                totalImpacted: report.totalImpacted
+              },
+              null,
+              2
+            );
           } else if (toolName === 'synapse_rollback') {
             const report = await rollbackSliceMigrations(this.root, undefined, {
               targetSlice: args.targetSlice,
@@ -659,6 +539,225 @@ export class SynapseMcpServer {
             const transcriptTail = String(args.transcriptTail || '');
             const result: NudgeGateResult = await shouldNudgeContinuation(transcriptTail);
             contentText = JSON.stringify(result, null, 2);
+          } else if (toolName === 'synapse_inspect_routes') {
+            const resolution = resolveSlicesDir(this.root);
+            if (!resolution.ok) {
+              return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                  isError: true,
+                  content: [
+                    {
+                      type: 'text',
+                      text: JSON.stringify({ status: 'FAIL', code: resolution.error.code }, null, 2)
+                    }
+                  ]
+                }
+              };
+            }
+            const sliceFiles = findSliceFiles(resolution.value.slicesDir);
+            const routes = sliceFiles.map((file) => {
+              const rel = path.relative(resolution.value.slicesDir, file);
+              const parts = rel.split(path.sep);
+              const domain = parts[0] || 'general';
+              const name = path.basename(file, '.slice.tsx');
+              const code = fs.readFileSync(file, 'utf-8');
+              return {
+                sliceKey: `${domain}/${name}`,
+                routePath: `/${domain}/${name}`,
+                rpcPath: `/_synapse/rpc/${domain}/${name}`,
+                dynamicPath: `/${domain}/${name}/:id`,
+                filePath: toRelativePath(this.root, file),
+                hasAction: /export\s+async\s+function\s+\w+Action\b/.test(code),
+                hasLoader: /export\s+async\s+function\s+\w+Loader\b/.test(code),
+                hasComponent: /export\s+function\s+\w+(Trigger|View|Form|Component)\b/.test(code),
+                hasCache: /export\s+const\s+sliceCache\s*=/.test(code),
+                hasJob: /\bdefineJob\s*[<(]/.test(code)
+              };
+            });
+            contentText = JSON.stringify(
+              {
+                status: 'PASS',
+                operation: 'INSPECT_ROUTES',
+                totalRoutes: routes.length,
+                routes
+              },
+              null,
+              2
+            );
+          } else if (toolName === 'synapse_test_slice') {
+            const targetSlice = String(args.targetSlice || '');
+            if (!targetSlice) {
+              return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                  isError: true,
+                  content: [
+                    {
+                      type: 'text',
+                      text: JSON.stringify({ status: 'FAIL', code: 'MISSING_TARGET_SLICE' }, null, 2)
+                    }
+                  ]
+                }
+              };
+            }
+            const report = await runSliceOracles(this.root, { targetSlice });
+            contentText = JSON.stringify(report, null, 2);
+          } else if (toolName === 'synapse_generate_seed') {
+            const targetSlice = String(args.targetSlice || '');
+            const count = Math.min(Math.max(Number(args.count) || 5, 1), 50);
+            const resolution = resolveSlicesDir(this.root);
+            if (!resolution.ok) {
+              return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                  isError: true,
+                  content: [
+                    {
+                      type: 'text',
+                      text: JSON.stringify({ status: 'FAIL', code: resolution.error.code }, null, 2)
+                    }
+                  ]
+                }
+              };
+            }
+            const sliceFiles = findSliceFiles(resolution.value.slicesDir);
+            const matchedFile = sliceFiles.find((f) => {
+              const name = path.basename(f, '.slice.tsx');
+              const rel = path.relative(resolution.value.slicesDir, f);
+              return name === targetSlice || rel.startsWith(targetSlice) || rel.includes(targetSlice);
+            });
+            if (!matchedFile) {
+              contentText = JSON.stringify(
+                {
+                  status: 'FAIL',
+                  code: 'SLICE_NOT_FOUND',
+                  message: `Fatia "${targetSlice}" não encontrada para gerar seed.`
+                },
+                null,
+                2
+              );
+            } else {
+              const code = fs.readFileSync(matchedFile, 'utf-8');
+              const tableMatch = code.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([a-zA-Z0-9_]+)/i);
+              const tableName = tableMatch
+                ? tableMatch[1]
+                : path.basename(matchedFile, '.slice.tsx').replace(/-/g, '_');
+              const { getDatabase } = await import('../core/database-factory');
+              const dbClient = getDatabase();
+              const generatedRows: Record<string, unknown>[] = [];
+              let insertedCount = 0;
+              for (let i = 1; i <= count; i++) {
+                const row = {
+                  id: crypto.randomUUID(),
+                  name: `Seed Item ${i}`,
+                  sku: `SEED-${Math.random().toString(36).substring(2, 7).toUpperCase()}`,
+                  price: parseFloat((10 + Math.random() * 90).toFixed(2)),
+                  stock: Math.floor(1 + Math.random() * 100),
+                  status: i % 3 === 0 ? 'low_stock' : 'active',
+                  created_at: new Date().toISOString()
+                };
+                generatedRows.push(row);
+                try {
+                  await dbClient.insert(tableName, row);
+                  insertedCount++;
+                } catch {
+                  try {
+                    await dbClient.query(`INSERT INTO ${tableName} (id, name) VALUES ($1, $2)`, [row.id, row.name]);
+                    insertedCount++;
+                  } catch {}
+                }
+              }
+              await dbClient.close?.();
+              contentText = JSON.stringify(
+                {
+                  status: insertedCount > 0 ? 'PASS' : 'FAIL',
+                  operation: 'GENERATE_SEED',
+                  slice: targetSlice,
+                  table: tableName,
+                  ...(insertedCount > 0 ? {} : { code: 'SEED_INSERT_FAILED' }),
+                  recordsSynthesized: count,
+                  recordsInserted: insertedCount,
+                  sample: generatedRows[0]
+                },
+                null,
+                2
+              );
+            }
+          } else if (toolName === 'synapse_scaffold_component') {
+            const domain = String(args.domain || 'general');
+            const name = String(args.name || 'component');
+            const componentType = String(args.componentType || 'modal');
+
+            const domainValid = validatePathSegment(domain);
+            const nameValid = validatePathSegment(name);
+            if (!domainValid.ok || !nameValid.ok) {
+              return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                  isError: true,
+                  content: [
+                    {
+                      type: 'text',
+                      text: JSON.stringify({ status: 'FAIL', code: 'INVALID_PATH_SEGMENT' }, null, 2)
+                    }
+                  ]
+                }
+              };
+            }
+
+            const resolution = resolveSlicesDir(this.root);
+            let slicesDir: string;
+            if (resolution.ok) {
+              slicesDir = resolution.value.slicesDir;
+            } else if (resolution.error.code === 'AMBIGUOUS_SLICES_DIR') {
+              return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                  isError: true,
+                  content: [
+                    {
+                      type: 'text',
+                      text: JSON.stringify({ status: 'FAIL', code: resolution.error.code }, null, 2)
+                    }
+                  ]
+                }
+              };
+            } else {
+              slicesDir = path.join(path.resolve(this.root), 'src', 'slices');
+            }
+            const outPath = path.join(slicesDir, domain, `${name}.tsx`);
+            fs.mkdirSync(path.dirname(outPath), { recursive: true });
+            const pascal = name
+              .split(/[-_]/)
+              .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+              .join('');
+            let componentCode = '';
+            if (componentType === 'modal') {
+              componentCode = `import React, { useState } from 'react';\nimport { Modal, Button } from 'synapsejs/client';\n\nexport function ${pascal}() {\n  const [isOpen, setIsOpen] = useState(false);\n  return (\n    <div>\n      <Button onClick={() => setIsOpen(true)}>Abrir ${pascal}</Button>\n      <Modal isOpen={isOpen} onClose={() => setIsOpen(false)} title="${pascal}">\n        <p className="text-slate-300">Conteúdo interativo do modal gerenciado no cliente.</p>\n      </Modal>\n    </div>\n  );\n}\n`;
+            } else if (componentType === 'drawer') {
+              componentCode = `import React, { useState } from 'react';\nimport { Drawer, Button } from 'synapsejs/client';\n\nexport function ${pascal}() {\n  const [isOpen, setIsOpen] = useState(false);\n  return (\n    <div>\n      <Button onClick={() => setIsOpen(true)}>Exibir ${pascal}</Button>\n      <Drawer isOpen={isOpen} onClose={() => setIsOpen(false)} title="${pascal}">\n        <p className="text-slate-300">Painel lateral deslizante.</p>\n      </Drawer>\n    </div>\n  );\n}\n`;
+            } else if (componentType === 'tabs') {
+              componentCode = `import React from 'react';\nimport { Tabs, TabList, Tab, TabPanel } from 'synapsejs/client';\n\nexport function ${pascal}() {\n  return (\n    <Tabs defaultValue="tab1">\n      <TabList>\n        <Tab value="tab1">Aba 1</Tab>\n        <Tab value="tab2">Aba 2</Tab>\n      </TabList>\n      <TabPanel value="tab1"><div className="p-4 text-slate-300">Painel 1</div></TabPanel>\n      <TabPanel value="tab2"><div className="p-4 text-slate-300">Painel 2</div></TabPanel>\n    </Tabs>\n  );\n}\n`;
+            } else {
+              componentCode = `import React from 'react';\nimport { DropdownMenu, DropdownItem, Button } from 'synapsejs/client';\n\nexport function ${pascal}() {\n  return (\n    <DropdownMenu trigger={<Button variant="secondary">Ações ▾</Button>}>\n      <DropdownItem onClick={() => alert('Opção 1')}>Opção 1</DropdownItem>\n      <DropdownItem variant="danger" onClick={() => alert('Excluir')}>Excluir</DropdownItem>\n    </DropdownMenu>\n  );\n}\n`;
+            }
+            fs.writeFileSync(outPath, componentCode, 'utf-8');
+            contentText = JSON.stringify(
+              {
+                status: 'PASS',
+                operation: 'SCAFFOLD_COMPONENT',
+                componentType,
+                filePath: toRelativePath(this.root, outPath)
+              },
+              null,
+              2
+            );
           } else {
             return {
               jsonrpc: '2.0',