@ismaelsoilet/synapsejs 1.9.0 → 1.11.1

package/src/mcp/server.ts

@@ -28,10 +28,11 @@ 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';
 
@@ -414,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') {
@@ -502,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',

package/src/mcp/tools.ts

@@ -73,7 +73,7 @@ export const MCP_TOOLS: McpToolDefinition[] = [
         },
         template: {
           type: 'string',
-          enum: ['create', 'list', 'update', 'delete', 'login', 'oauth-github', 'crud'],
+          enum: ['create', 'list', 'update', 'delete', 'login', 'oauth-github', 'crud', 'modal-crud'],
           description: 'Optional slice template shape (default: create)'
         },
         fields: {
@@ -84,6 +84,27 @@ export const MCP_TOOLS: McpToolDefinition[] = [
       }
     }
   },
+  {
+    name: 'synapse_scaffold_domain',
+    description:
+      'Scaffold an entire modular domain directory with domain layout (_layout.tsx), initial list slice, and shared module (src/shared/<domain>.ts)',
+    inputSchema: {
+      type: 'object',
+      required: ['domain'],
+      properties: {
+        domain: {
+          type: 'string',
+          pattern: PATH_SEGMENT_PATTERN,
+          description: 'Domain name (e.g. billing, customers, orders)'
+        },
+        fields: {
+          type: 'string',
+          description:
+            'Optional initial fields grammar, e.g. "name:string,email:string,status:enum(ACTIVE|INACTIVE),price:number"'
+        }
+      }
+    }
+  },
   {
     name: 'synapse_contract',
     description:
@@ -231,6 +252,76 @@ export const MCP_TOOLS: McpToolDefinition[] = [
         }
       }
     }
+  },
+  {
+    name: 'synapse_inspect_routes',
+    description:
+      'Inspect all active slice routes, dynamic path parameters, HTTP verbs, caching policies, and registered RPC endpoints as structured JSON for AI context',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  {
+    name: 'synapse_test_slice',
+    description:
+      'Execute Fast-Check Property-Based Testing (PBT) invariant test suite for one specific targeted slice without running the entire codebase',
+    inputSchema: {
+      type: 'object',
+      required: ['targetSlice'],
+      properties: {
+        targetSlice: {
+          type: 'string',
+          description:
+            'Name or key of the slice to run oracles for (e.g. overview, create-item, or inventory/create-item)'
+        }
+      }
+    }
+  },
+  {
+    name: 'synapse_generate_seed',
+    description:
+      'Synthesize realistic, valid TypeBox-compliant database seed records using Fast-Check arbitraries directly into the live SQLite/PostgreSQL database',
+    inputSchema: {
+      type: 'object',
+      required: ['targetSlice'],
+      properties: {
+        targetSlice: {
+          type: 'string',
+          description: 'Name or key of the slice whose table to seed (e.g. create-item or inventory/create-item)'
+        },
+        count: {
+          type: 'number',
+          description: 'Number of seed records to synthesize and insert (default: 5)'
+        }
+      }
+    }
+  },
+  {
+    name: 'synapse_scaffold_component',
+    description:
+      'Scaffold interactive client sub-components (with Modal, Drawer, Tabs or Dropdown) ready to be embedded or transcluded via SubSlice',
+    inputSchema: {
+      type: 'object',
+      required: ['domain', 'name', 'componentType'],
+      properties: {
+        domain: {
+          type: 'string',
+          pattern: PATH_SEGMENT_PATTERN,
+          description: 'Domain name (e.g. billing, inventory, settings)'
+        },
+        name: {
+          type: 'string',
+          pattern: PATH_SEGMENT_PATTERN,
+          description: 'Component name in kebab-case (e.g. item-details-modal)'
+        },
+        componentType: {
+          type: 'string',
+          enum: ['modal', 'drawer', 'tabs', 'dropdown'],
+          description: 'Interactive primitive type to scaffold'
+        }
+      }
+    }
   }
 ];
 

package/src/project-status.ts

@@ -279,6 +279,109 @@ export const FEATURE_STATUS: FeatureStatus[] = [
     status: 'stable',
     evidence: 'bun test packages/synapse/test/feature-exercise.test.ts (rollback rolls back a real statement)'
   },
+  {
+    feature: 'Query aggregations, GROUP BY and portable HAVING',
+    status: 'stable',
+    evidence:
+      'bun test packages/synapse/test/query-builder.test.ts; TEST_DATABASE_URL=... bun test packages/synapse/test/postgres-adapters.test.ts'
+  },
+  {
+    feature: 'Cron scheduling with POSIX DOM/DOW semantics and runAt',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/cron-queue.test.ts'
+  },
+  {
+    feature: 'PostgreSQL cron scope fails with CRON_UNSUPPORTED_ENGINE',
+    status: 'stable',
+    evidence: 'TEST_DATABASE_URL=... bun test packages/synapse/test/postgres-adapters.test.ts'
+  },
+  {
+    feature: 'Fine-grained permissions inside signed session tokens',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/session-security.test.ts'
+  },
+  {
+    feature: 'OAuth PKCE, state validation and bounded token exchange',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/session-security.test.ts'
+  },
+  {
+    feature: 'Local CSS bundle without a CDN',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/css-bundle.test.ts'
+  },
+  {
+    feature: 'Client error boundary for slice render failures',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/hydration.test.tsx'
+  },
+  {
+    feature: 'SPA morphing preserves focus and form state',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/turbo-router.test.tsx'
+  },
+  {
+    feature: 'Transactional domain scaffolding (new-domain)',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/scaffolder.test.ts'
+  },
+  {
+    feature: 'Large-slice warning (WARN_LARGE_SLICE)',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/slice-splitter.test.ts'
+  },
+  {
+    feature: 'TypeScript compiler API guard (COMPILER_API_UNAVAILABLE)',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/compiler-api.test.ts'
+  },
+  {
+    feature: 'Accessible UI primitives (Modal, Drawer, Tabs, Dropdown, Toast)',
+    status: 'stable',
+    evidence:
+      'bun test packages/synapse/test/ui-primitives.test.tsx packages/synapse/test/ui-primitives-client.test.tsx'
+  },
+  {
+    feature: 'Isomorphic dynamic route parameters (useParams/useSearchParams)',
+    status: 'stable',
+    evidence:
+      'bun test packages/synapse/test/dynamic-routes.test.tsx packages/synapse/test/dynamic-routes-client.test.tsx'
+  },
+  {
+    feature: 'Streaming HTTP responses (ctx.stream, chunked transfer)',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/streaming-oauth.test.ts'
+  },
+  {
+    feature: 'Client upload hook with progress and abort (useUpload)',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/upload-hook.test.tsx'
+  },
+  {
+    feature: 'Multi-provider OAuth presets and profile normalization (Google/GitHub/Discord)',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/streaming-oauth.test.ts'
+  },
+  {
+    feature: 'Native MCP server with 23 tools, including route/seed/slice/component tools',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/mcp-server.test.ts'
+  },
+  {
+    feature: 'Modal CRUD slice scaffolding (--template=modal-crud)',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/scaffolder.test.ts'
+  },
+  {
+    feature: 'Vendor bundle auto-rebuild and client-primitive exports',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/client-bundler.test.ts'
+  },
+  {
+    feature: 'Hydration URL synchronization and interactive modal/dropdown semantics',
+    status: 'stable',
+    evidence: 'bun test packages/synapse/test/client-entry.test.ts packages/synapse/test/ui-primitives-client.test.tsx'
+  },
   {
     feature: 'Incremental diagnostics cache across processes',
     status: 'roadmap',

package/src/runtime/client-entry.ts

@@ -45,13 +45,14 @@ export function clientEntrySource(options: ClientEntryOptions): string {
     `// [SYNAPSE-JS GENERATED CLIENT ENTRY] hydrates the slice in the browser`,
     `import React from 'react';`,
     `import { hydrateRoot } from 'react-dom/client';`,
-    `import { rpcCall, SynapseProvider } from 'synapsejs/client';`,
+    `import { rpcCall, SynapseProvider, ToastProvider } from 'synapsejs/client';`,
     ...layoutImports,
     `import { ${options.componentName} } from ${JSON.stringify(options.clientModulePath)};`,
     ``,
     `export function hydrate() {`,
     `  const scope = globalThis as unknown as Record<string, unknown>;`,
     `  const props = (scope[${JSON.stringify(CLIENT_PROPS_GLOBAL)}] ?? {}) as Record<string, unknown>;`,
+    `  const currentUrl = (scope.__SYNAPSE_URL__ as string) || (typeof window !== 'undefined' ? window.location.href : '/');`,
     `  const root = document.getElementById(${JSON.stringify(rootId)});`,
     `  if (root) {`,
     `    const sliceElement = React.createElement(${options.componentName}, {`,
@@ -71,22 +72,27 @@ export function clientEntrySource(options: ClientEntryOptions): string {
         `    const RootLayout = (RootLayoutModule as any).default || (RootLayoutModule as any).Layout || null;`
       );
     }
+    lines.push(`    const layoutProps = { ...props, url: currentUrl };`);
     let treeExpr = 'sliceElement';
     if (options.domainLayoutPath) {
-      treeExpr = `(typeof DomainLayout === 'function' ? React.createElement(DomainLayout, { ...props }, ${treeExpr}) : ${treeExpr})`;
+      treeExpr = `(typeof DomainLayout === 'function' ? React.createElement(DomainLayout, layoutProps, ${treeExpr}) : ${treeExpr})`;
     }
     if (options.rootLayoutPath) {
-      treeExpr = `(typeof RootLayout === 'function' ? React.createElement(RootLayout, { ...props }, ${treeExpr}) : ${treeExpr})`;
+      treeExpr = `(typeof RootLayout === 'function' ? React.createElement(RootLayout, layoutProps, ${treeExpr}) : ${treeExpr})`;
     }
     lines.push(`    const treeWithLayout = ${treeExpr};`);
     lines.push(`    hydrateRoot(`);
     lines.push(`      root,`);
-    lines.push(`      React.createElement(SynapseProvider, { props, session: props.session as any }, treeWithLayout)`);
+    lines.push(
+      `      React.createElement(SynapseProvider, { props, session: props.session as any, url: currentUrl }, React.createElement(ToastProvider, null, treeWithLayout))`
+    );
     lines.push(`    );`);
   } else {
     lines.push(`    hydrateRoot(`);
     lines.push(`      root,`);
-    lines.push(`      React.createElement(SynapseProvider, { props, session: props.session as any }, sliceElement)`);
+    lines.push(
+      `      React.createElement(SynapseProvider, { props, session: props.session as any, url: currentUrl }, React.createElement(ToastProvider, null, sliceElement))`
+    );
     lines.push(`    );`);
   }