@veraxhq/verax 0.1.0 → 0.2.1

package/src/verax/learn/ast-contract-extractor.js

@@ -4,6 +4,7 @@ import { readFileSync } from 'fs';
 import { glob } from 'glob';
 import { resolve } from 'path';
 import { ExpectationProof } from '../shared/expectation-proof.js';
+import { normalizeTemplateLiteral } from '../shared/dynamic-route-utils.js';
 
 const MAX_FILES_TO_SCAN = 200;
 
@@ -20,6 +21,11 @@ function extractStaticStringValue(node) {
   if (node.type === 'StringLiteral') {
     return node.value;
   }
+
+  // Template literal without interpolation
+  if (node.type === 'TemplateLiteral' && node.expressions.length === 0 && node.quasis.length === 1) {
+    return node.quasis[0].value.cooked;
+  }
   
   // JSX expression: href={'/about'} or href={`/about`}
   if (node.type === 'JSXExpressionContainer') {
@@ -45,18 +51,89 @@ function extractStaticStringValue(node) {
   return null;
 }
 
+function extractStaticPropValue(propsNode, propNames) {
+  if (!propsNode || propsNode.type !== 'ObjectExpression') return { attributeName: null, targetPath: null };
+  const names = new Set(propNames);
+  for (const prop of propsNode.properties || []) {
+    if (prop.type !== 'ObjectProperty') continue;
+    const key = prop.key;
+    const name = key.type === 'Identifier' ? key.name : (key.type === 'StringLiteral' ? key.value : null);
+    if (!name || !names.has(name)) continue;
+    const targetPath = extractStaticStringValue(prop.value);
+    if (targetPath) {
+      return { attributeName: name, targetPath };
+    }
+  }
+  return { attributeName: null, targetPath: null };
+}
+
+/**
+ * Extracts template literal pattern from Babel TemplateLiteral node.
+ * Returns null if template has complex expressions that cannot be normalized.
+ * 
+ * Examples:
+ * - `${id}` → { pattern: '${id}', examplePath: '/1' }
+ * - `/users/${id}` → { pattern: '/users/${id}', examplePath: '/users/1' }
+ * - `/posts/${slug}` → { pattern: '/posts/${slug}', examplePath: '/posts/example' }
+ */
+function extractTemplatePattern(templateNode) {
+  if (!templateNode || templateNode.type !== 'TemplateLiteral') {
+    return null;
+  }
+  
+  // Build the template string with ${} placeholders
+  let templateStr = templateNode.quasis[0]?.value?.cooked || '';
+  
+  for (let i = 0; i < templateNode.expressions.length; i++) {
+    const expr = templateNode.expressions[i];
+    
+    // Only support simple identifiers: ${id}, ${slug}
+    if (expr.type === 'Identifier') {
+      templateStr += '${' + expr.name + '}';
+    } else {
+      // Complex expressions like function calls - cannot normalize
+      return null;
+    }
+    
+    // Add the next quasi
+    if (templateNode.quasis[i + 1]) {
+      templateStr += templateNode.quasis[i + 1].value.cooked || '';
+    }
+  }
+  
+  // Must be a valid route pattern (start with /)
+  if (!templateStr.startsWith('/')) {
+    return null;
+  }
+  
+  // Normalize to example path
+  const normalized = normalizeTemplateLiteral(templateStr);
+  if (normalized) {
+    return {
+      pattern: templateStr,
+      examplePath: normalized.examplePath,
+      isDynamic: true,
+      originalPattern: normalized.originalPattern
+    };
+  }
+  
+  return null;
+}
+
 /**
  * Extracts PROVEN navigation contracts from JSX elements and imperative calls.
  * 
- * Supported patterns (all require static string literals):
- * - Next.js: <Link href="/about">
- * - React Router: <Link to="/about"> or <NavLink to="/about">
+ * Supported patterns (all require static string literals or template patterns):
+ * - Next.js: <Link href="/about"> or <Link href={`/about`}>
+ * - React Router: <Link to="/about"> or <RouterLink :to="`/users/${id}`">
  * - Plain JSX: <a href="/about">
- * - Imperative: navigate("/about"), router.push("/about")
+ * - Imperative: navigate("/about"), router.push("/about"), router.push(`/users/${id}`)
  * 
  * Returns array of contracts with:
  * - kind: 'NAVIGATION'
- * - targetPath: string
+ * - targetPath: string (example path for dynamic routes)
+ * - originalPattern: string (original pattern for dynamic routes)
+ * - isDynamic: boolean (true if dynamic route)
  * - sourceFile: string
  * - element: 'Link' | 'NavLink' | 'a' | 'navigate' | 'router'
  * - attribute: 'href' | 'to' (for runtime matching)
@@ -120,6 +197,37 @@ function extractContractsFromFile(filePath, fileContent) {
       // since we cannot reliably tie them to clicked elements
       CallExpression(path) {
         const callee = path.node.callee;
+
+        // React.createElement(Link, { to: '/about' }) or createElement('a', { href: '/about' })
+        const isCreateElement = (
+          (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'React' && callee.property.type === 'Identifier' && callee.property.name === 'createElement') ||
+          (callee.type === 'Identifier' && callee.name === 'createElement')
+        );
+
+        if (isCreateElement) {
+          const [componentArg, propsArg] = path.node.arguments;
+          let elementName = null;
+          if (componentArg?.type === 'Identifier') {
+            elementName = componentArg.name;
+          } else if (componentArg?.type === 'StringLiteral') {
+            elementName = componentArg.value;
+          }
+          if (elementName) {
+            const { attributeName, targetPath } = extractStaticPropValue(propsArg, ['to', 'href']);
+            if (targetPath && !targetPath.startsWith('http://') && !targetPath.startsWith('https://') && !targetPath.startsWith('mailto:') && !targetPath.startsWith('tel:')) {
+              const normalized = targetPath.startsWith('/') ? targetPath : '/' + targetPath;
+              contracts.push({
+                kind: 'NAVIGATION',
+                targetPath: normalized,
+                sourceFile: filePath,
+                element: elementName,
+                attribute: attributeName,
+                proof: ExpectationProof.PROVEN_EXPECTATION,
+                line: path.node.loc?.start.line || null
+              });
+            }
+          }
+        }
         
         // navigate("/about") - useNavigate hook
         if (callee.type === 'Identifier' && callee.name === 'navigate') {
@@ -138,6 +246,23 @@ function extractContractsFromFile(filePath, fileContent) {
                 imperativeOnly: true // Cannot match to DOM element
               });
             }
+          } else if (firstArg && firstArg.type === 'TemplateLiteral') {
+            // Template literal: navigate(`/users/${id}`)
+            const templatePattern = extractTemplatePattern(firstArg);
+            if (templatePattern) {
+              contracts.push({
+                kind: 'NAVIGATION',
+                targetPath: templatePattern.examplePath,
+                originalPattern: templatePattern.pattern,
+                isDynamic: true,
+                sourceFile: filePath,
+                element: 'navigate',
+                attribute: null,
+                proof: ExpectationProof.PROVEN_EXPECTATION,
+                line: path.node.loc?.start.line || null,
+                imperativeOnly: true // Cannot match to DOM element
+              });
+            }
           }
         }
         
@@ -162,6 +287,23 @@ function extractContractsFromFile(filePath, fileContent) {
                 imperativeOnly: true // Cannot match to DOM element
               });
             }
+          } else if (firstArg && firstArg.type === 'TemplateLiteral') {
+            // Template literal: router.push(`/users/${id}`)
+            const templatePattern = extractTemplatePattern(firstArg);
+            if (templatePattern) {
+              contracts.push({
+                kind: 'NAVIGATION',
+                targetPath: templatePattern.examplePath,
+                originalPattern: templatePattern.pattern,
+                isDynamic: true,
+                sourceFile: filePath,
+                element: 'router',
+                attribute: null,
+                proof: ExpectationProof.PROVEN_EXPECTATION,
+                line: path.node.loc?.start.line || null,
+                imperativeOnly: true // Cannot match to DOM element
+              });
+            }
           }
         }
       }
@@ -218,7 +360,7 @@ export async function extractASTContracts(projectDir) {
  * Converts AST contracts to manifest expectations format.
  * Only includes contracts that can be matched at runtime (excludes imperativeOnly).
  */
-export function contractsToExpectations(contracts, projectType) {
+export function contractsToExpectations(contracts, _projectType) {
   const expectations = [];
   const seenPaths = new Set();
   

package/src/verax/learn/flow-extractor.js

@@ -0,0 +1,172 @@
+/**
+ * FLOW INTELLIGENCE v1 — Flow Extractor
+ * 
+ * Extracts multi-step flows from PROVEN expectations.
+ * NO HEURISTICS: Only sequences with explicit PROVEN expectations qualify as flows.
+ */
+
+import { createHash } from 'crypto';
+import { isProvenExpectation } from '../shared/expectation-prover.js';
+
+/**
+ * Generate stable flow ID from ordered steps
+ */
+function generateFlowId(steps) {
+  const hashInput = steps.map(s => `${s.expectationType}:${s.source || s.handlerRef}`).join('|');
+  const hash = createHash('sha256').update(hashInput).digest('hex');
+  return `flow-${hash.substring(0, 8)}`;
+}
+
+/**
+ * Determine if an expectation can be part of a flow.
+ * Only PROVEN expectations with clear sequential intent qualify.
+ */
+function isFlowableExpectation(exp) {
+  // Navigation expectations: always flowable (user journey)
+  if (exp.expectationType === 'navigation') return true;
+  
+  // Network actions: flowable (form submissions, API calls)
+  if (exp.kind === 'NETWORK_ACTION') return true;
+  
+  // State actions: flowable (state updates in sequence)
+  if (exp.kind === 'STATE_ACTION') return true;
+  
+  // Validation blocks: NOT flowable alone (they block, don't progress)
+  if (exp.kind === 'VALIDATION_BLOCK') return false;
+  
+  return false;
+}
+
+/**
+ * Extract flows from manifest expectations.
+ * 
+ * Flow definition:
+ * - Sequence of 2-5 PROVEN expectations
+ * - Temporally ordered within same route/page
+ * - Each step must be deterministically executable
+ * 
+ * @param {Object} manifest - Learned manifest
+ * @returns {Array} Array of flow definitions
+ */
+export function extractFlows(manifest) {
+  const flows = [];
+  
+  // Collect all flowable expectations
+  const flowableExpectations = [];
+  
+  // SPA expectations (navigation)
+  if (manifest.spaExpectations && manifest.spaExpectations.length > 0) {
+    for (const exp of manifest.spaExpectations) {
+      if (isFlowableExpectation(exp)) {
+        flowableExpectations.push({
+          source: exp.source || exp.sourceFile,
+          expectationType: 'navigation',
+          targetPath: exp.targetPath,
+          proof: 'PROVEN_EXPECTATION',
+          raw: exp
+        });
+      }
+    }
+  }
+  
+  // Action contracts (network, state)
+  if (manifest.actionContracts && manifest.actionContracts.length > 0) {
+    for (const contract of manifest.actionContracts) {
+      if (isFlowableExpectation(contract)) {
+        flowableExpectations.push({
+          source: contract.source,
+          handlerRef: contract.handlerRef,
+          expectationType: contract.kind === 'NETWORK_ACTION' ? 'network_action' : 'state_action',
+          method: contract.method,
+          urlPath: contract.urlPath,
+          proof: 'PROVEN_EXPECTATION',
+          raw: contract
+        });
+      }
+    }
+  }
+  
+  // Static expectations (navigation, network_action, form submissions)
+  if (manifest.staticExpectations && manifest.staticExpectations.length > 0) {
+    for (const exp of manifest.staticExpectations) {
+      // FLOW INTELLIGENCE v1: Only include PROVEN expectations
+      if (!isProvenExpectation(exp)) continue;
+      
+      let expType = null;
+      if (exp.type === 'navigation' || exp.type === 'spa_navigation') {
+        expType = 'navigation';
+      } else if (exp.type === 'network_action') {
+        expType = 'network_action';
+      } else if (exp.type === 'form_submission') {
+        expType = 'network_action'; // Form submissions are network actions
+      } else {
+        continue; // Skip non-flowable types
+      }
+      
+      flowableExpectations.push({
+        source: exp.evidence?.source || exp.fromPath || exp.metadata?.elementFile,
+        handlerRef: exp.handlerRef || exp.metadata?.handlerFile,
+        expectationType: expType,
+        targetPath: exp.targetPath || exp.expectedTarget,
+        urlPath: exp.urlPath || exp.expectedTarget,
+        method: exp.method,
+        proof: 'PROVEN_EXPECTATION',
+        raw: exp
+      });
+    }
+  }
+  
+  // DETERMINISTIC FLOW DETECTION: Group by source page
+  // Flows are sequences on the same page (same source file/route)
+  const bySource = new Map();
+  
+  for (const exp of flowableExpectations) {
+    // Extract file name from source (e.g., "index.html" from "index.html:56:68")
+    let sourceKey = 'unknown';
+    if (exp.source) {
+      sourceKey = exp.source.split(':')[0]; // Get filename part
+    } else if (exp.handlerRef) {
+      sourceKey = exp.handlerRef.split(':')[0];
+    }
+    
+    if (!bySource.has(sourceKey)) {
+      bySource.set(sourceKey, []);
+    }
+    bySource.get(sourceKey).push(exp);
+  }
+  
+  // For each source, create flows of 2-5 sequential expectations
+  for (const [source, expectations] of bySource.entries()) {
+    if (expectations.length < 2) continue; // Need at least 2 for a flow
+    
+    // Take sequences of 2-5 expectations as potential flows
+    const maxFlowLength = Math.min(5, expectations.length);
+    
+    for (let length = 2; length <= maxFlowLength; length++) {
+      // Only create one flow per source (the full sequence up to 5 steps)
+      if (length === Math.min(expectations.length, 5)) {
+        const flowSteps = expectations.slice(0, length).map((exp, idx) => ({
+          stepIndex: idx,
+          expectationType: exp.expectationType,
+          source: exp.source,
+          handlerRef: exp.handlerRef,
+          targetPath: exp.targetPath,
+          method: exp.method,
+          urlPath: exp.urlPath
+        }));
+        
+        const flowId = generateFlowId(flowSteps);
+        
+        flows.push({
+          flowId,
+          source,
+          stepCount: length,
+          steps: flowSteps,
+          proof: 'PROVEN_EXPECTATION'
+        });
+      }
+    }
+  }
+  
+  return flows;
+}

package/src/verax/learn/index.js

@@ -1,9 +1,31 @@
 import { resolve } from 'path';
-import { existsSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { detectProjectType } from './project-detector.js';
 import { extractRoutes } from './route-extractor.js';
 import { writeManifest } from './manifest-writer.js';
 
+/**
+ * @typedef {Object} LearnResult
+ * @property {number} version
+ * @property {string} learnedAt
+ * @property {string} projectDir
+ * @property {string} projectType
+ * @property {Array} routes
+ * @property {Array<string>} publicRoutes
+ * @property {Array<string>} internalRoutes
+ * @property {Array} [staticExpectations]
+ * @property {Array} [flows]
+ * @property {string} [expectationsStatus]
+ * @property {Array} [coverageGaps]
+ * @property {Array} notes
+ * @property {Object} [learnTruth]
+ * @property {string} [manifestPath] - Optional manifest path (added when loaded from file)
+ */
+
+/**
+ * @param {string} projectDir
+ * @returns {Promise<LearnResult>}
+ */
 export async function learn(projectDir) {
   const absoluteProjectDir = resolve(projectDir);
   
@@ -14,5 +36,17 @@ export async function learn(projectDir) {
   const projectType = await detectProjectType(absoluteProjectDir);
   const routes = await extractRoutes(absoluteProjectDir, projectType);
   
-  return await writeManifest(absoluteProjectDir, projectType, routes);
+    const manifest = await writeManifest(absoluteProjectDir, projectType, routes);
+  
+    // Write manifest to disk and return path
+    const veraxDir = resolve(absoluteProjectDir, '.verax');
+    mkdirSync(veraxDir, { recursive: true });
+  
+    const manifestPath = resolve(veraxDir, 'project.json');
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+  
+    return {
+      ...manifest,
+      manifestPath
+    };
 }

package/src/verax/learn/manifest-writer.js

@@ -1,12 +1,35 @@
-import { resolve } from 'path';
-import { writeFileSync, mkdirSync } from 'fs';
+// resolve, writeFileSync, mkdirSync imports removed - currently unused
 import { extractStaticExpectations } from './static-extractor.js';
 import { assessLearnTruth } from './truth-assessor.js';
-import { ExpectationProof } from '../shared/expectation-proof.js';
-import { extractASTContracts, contractsToExpectations } from './ast-contract-extractor.js';
-import { scanForContracts } from './action-contract-extractor.js';
-import { resolveActionContracts } from './ts-contract-resolver.js';
+import { runCodeIntelligence } from '../intel/index.js';
+import { isProvenExpectation } from '../shared/expectation-prover.js';
+import { extractFlows } from './flow-extractor.js';
+import { createTSProgram } from '../intel/ts-program.js';
+import { extractVueNavigationPromises } from '../intel/vue-navigation-extractor.js';
 
+/**
+ * @typedef {Object} Manifest
+ * @property {number} version
+ * @property {string} learnedAt
+ * @property {string} projectDir
+ * @property {string} projectType
+ * @property {Array} routes
+ * @property {Array<string>} publicRoutes
+ * @property {Array<string>} internalRoutes
+ * @property {Array} [staticExpectations]
+ * @property {Array} [flows]
+ * @property {string} [expectationsStatus]
+ * @property {Array} [coverageGaps]
+ * @property {Array} notes
+ * @property {Object} [learnTruth]
+ */
+
+/**
+ * @param {string} projectDir
+ * @param {string} projectType
+ * @param {Array} routes
+ * @returns {Promise<Manifest>}
+ */
 export async function writeManifest(projectDir, projectType, routes) {
   const publicRoutes = routes.filter(r => r.public).map(r => r.path);
   const internalRoutes = routes.filter(r => !r.public).map(r => r.path);
@@ -19,7 +42,8 @@ export async function writeManifest(projectDir, projectType, routes) {
     routes: routes.map(r => ({
       path: r.path,
       source: r.source,
-      public: r.public
+      public: r.public,
+      sourceRef: r.sourceRef || null
     })),
     publicRoutes: publicRoutes,
     internalRoutes: internalRoutes,
@@ -27,71 +51,111 @@ export async function writeManifest(projectDir, projectType, routes) {
   };
   
   let staticExpectations = null;
-  let spaExpectations = null;
-  let actionContracts = null;
+  let intelExpectations = [];
+  let allExpectations = [];
   
+  // Static sites: extract from HTML
   if (projectType === 'static' && routes.length > 0) {
     staticExpectations = await extractStaticExpectations(projectDir, routes);
     manifest.staticExpectations = staticExpectations;
-    manifest.expectationProof = ExpectationProof.PROVEN_EXPECTATION;
-  } else if (projectType === 'react_spa' || projectType.startsWith('nextjs_')) {
-    // Wave 1 - CODE TRUTH ENGINE: Extract PROVEN contracts from AST
-    const contracts = await extractASTContracts(projectDir);
-    spaExpectations = contractsToExpectations(contracts, projectType);
+    allExpectations = staticExpectations || [];
+  }
+
+  // Vue projects: extract navigation promises from code
+  if (projectType === 'vue_router' || projectType === 'vue_spa') {
+    const program = createTSProgram(projectDir, { includeJs: true });
     
-    if (spaExpectations.length > 0) {
-      manifest.spaExpectations = spaExpectations;
-      manifest.expectationProof = ExpectationProof.PROVEN_EXPECTATION;
-    } else {
-      manifest.expectationProof = ExpectationProof.UNKNOWN_EXPECTATION;
+    if (!program.error) {
+      const vueNavPromises = await extractVueNavigationPromises(program, projectDir);
+      
+      if (vueNavPromises && vueNavPromises.length > 0) {
+        intelExpectations = vueNavPromises.filter(exp => isProvenExpectation(exp));
+        
+        if (!manifest.staticExpectations) {
+          manifest.staticExpectations = [];
+        }
+        manifest.staticExpectations.push(...intelExpectations);
+        allExpectations = intelExpectations;
+      }
     }
-  } else {
-    manifest.expectationProof = ExpectationProof.UNKNOWN_EXPECTATION;
   }
   
-  // Wave 5/6 - ACTION CONTRACTS: Extract network action contracts (Babel inline + TS cross-file)
-  const shouldExtractActions = projectType === 'react_spa' || projectType.startsWith('nextjs_');
-  if (shouldExtractActions) {
-    const [babelContracts, tsContracts] = await Promise.all([
-      scanForContracts(projectDir, projectDir),
-      resolveActionContracts(projectDir, projectDir).catch(() => [])
-    ]);
-    const merged = dedupeActionContracts([...(babelContracts || []), ...(tsContracts || [])]);
-    if (merged.length > 0) {
-      actionContracts = merged;
-      manifest.actionContracts = actionContracts;
+  // React SPAs, Next.js, and Vue: use code intelligence (AST-based) - NO FALLBACKS
+  if (projectType === 'react_spa' || 
+      projectType === 'nextjs_app_router' || 
+      projectType === 'nextjs_pages_router' ||
+      projectType === 'vue_router' ||
+      projectType === 'vue_spa') {
+    const intelResult = await runCodeIntelligence(projectDir);
+    
+    if (!intelResult.error && intelResult.expectations) {
+      // ZERO-HEURISTIC: Only include expectations that pass isProvenExpectation()
+      intelExpectations = intelResult.expectations.filter(exp => isProvenExpectation(exp));
+      
+      // STATE INTELLIGENCE: Also extract state expectations from AST
+      const { extractStateExpectationsFromAST } = await import('./state-extractor.js');
+      const stateResult = await extractStateExpectationsFromAST(projectDir);
+      
+      if (stateResult.expectations && stateResult.expectations.length > 0) {
+        // Convert state expectations to manifest format with sourceRef
+        const stateExpectations = stateResult.expectations.map(exp => ({
+          type: 'state_action',
+          expectedTarget: exp.expectedTarget,
+          storeType: exp.storeType,
+          proof: 'PROVEN_EXPECTATION',
+          sourceRef: exp.line ? `${exp.sourceFile}:${exp.line}` : exp.sourceFile,
+          selectorHint: null, // State actions don't have selector hints from AST
+          metadata: {
+            sourceFile: exp.sourceFile,
+            line: exp.line
+          }
+        })).filter(exp => isProvenExpectation(exp));
+        
+        intelExpectations.push(...stateExpectations);
+      }
+      
+      // Add intel expectations to manifest
+      if (!manifest.staticExpectations) {
+        manifest.staticExpectations = [];
+      }
+      manifest.staticExpectations.push(...intelExpectations);
+      allExpectations = intelExpectations;
     }
   }
-
-  const learnTruth = await assessLearnTruth(projectDir, projectType, routes, staticExpectations, spaExpectations);
+  
+  // ZERO-HEURISTIC: Set expectationsStatus and coverageGaps
+  const provenCount = allExpectations.filter(exp => isProvenExpectation(exp)).length;
+  
+  if (provenCount === 0 && (projectType === 'react_spa' || 
+      projectType === 'nextjs_app_router' || 
+      projectType === 'nextjs_pages_router' ||
+      projectType === 'vue_router' ||
+      projectType === 'vue_spa')) {
+    manifest.expectationsStatus = 'NO_PROVEN_EXPECTATIONS';
+    manifest.coverageGaps = [{
+      reason: 'NO_PROVEN_EXPECTATIONS_AVAILABLE',
+      message: 'Code intelligence found no extractable literal effects (navigation, network, validation) with static string literals',
+      projectType: projectType
+    }];
+  } else {
+    manifest.expectationsStatus = 'PROVEN_EXPECTATIONS_AVAILABLE';
+    manifest.coverageGaps = [];
+  }
+  
+  // FLOW INTELLIGENCE v1: Extract flows from PROVEN expectations
+  const flows = extractFlows(manifest);
+  if (flows.length > 0) {
+    manifest.flows = flows;
+  }
+  
+  const learnTruth = await assessLearnTruth(projectDir, projectType, routes, allExpectations);
   manifest.notes.push({
     type: 'truth',
     learn: learnTruth
   });
   
-  const manifestDir = resolve(projectDir, '.verax', 'learn');
-  mkdirSync(manifestDir, { recursive: true });
-  
-  const manifestPath = resolve(manifestDir, 'site-manifest.json');
-  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
-  
-  return {
-    ...manifest,
-    manifestPath: manifestPath,
-    learnTruth: learnTruth,
-    actionContracts
-  };
-}
-
-function dedupeActionContracts(contracts) {
-  const seen = new Set();
-  const out = [];
-  for (const c of contracts) {
-    const key = `${c.kind}|${c.method}|${c.urlPath}|${c.source || ''}|${c.handlerRef || ''}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(c);
-  }
-  return out;
+  // Note: This function is still used by learn() function
+  // Direct usage is deprecated in favor of CLI learn.json writer
+  return manifest;
 }