zefiro 0.3.7 → 0.5.0

package/dist/cli.js

@@ -4,14 +4,17 @@ import {
   error,
   header,
   info,
+  isDAGValid,
+  linearToDAG,
   require_picocolors,
   require_src,
   runStage1,
   setVerbose,
   success,
+  validateQAMapV3,
   verbose,
   warn
-} from "./cli-ek34kdc1.js";
+} from "./cli-fc97msmj.js";
 import {
   CONFIG_DIR,
   getPackageRoot,
@@ -7476,6 +7479,9 @@ function generateComponentId(filePath, componentName) {
   const hash = stableHash([filePath, componentName]);
   return `comp:${slugify(componentName)}-${hash}`;
 }
+function generateSectionId(name) {
+  return `sec:${slugify(name)}`;
+}
 function normalizeIds(qaMap) {
   const featureIdMap = new Map;
   const workflowIdMap = new Map;
@@ -7528,6 +7534,76 @@ function normalizeIds(qaMap) {
     scenarios: newScenarios
   };
 }
+function normalizeIdsV3(qaMap) {
+  const sectionIdMap = new Map;
+  const featureIdMap = new Map;
+  const workflowIdMap = new Map;
+  const componentIdMap = new Map;
+  for (const section of qaMap.sections) {
+    const newId = generateSectionId(section.name);
+    sectionIdMap.set(section.id, newId);
+  }
+  for (const feature of qaMap.features) {
+    const newId = generateFeatureId(feature.name, feature.routes);
+    featureIdMap.set(feature.id, newId);
+  }
+  for (const component of qaMap.components) {
+    const primaryFile = component.sourceFiles[0] ?? "";
+    const newId = generateComponentId(primaryFile, component.name);
+    componentIdMap.set(component.id, newId);
+  }
+  for (const workflow of qaMap.workflows) {
+    const newFeatureId = featureIdMap.get(workflow.featureId) ?? workflow.featureId;
+    const newId = generateWorkflowId(newFeatureId, workflow.name);
+    workflowIdMap.set(workflow.id, newId);
+  }
+  const newSections = qaMap.sections.map((s) => ({
+    ...s,
+    id: sectionIdMap.get(s.id) ?? s.id,
+    featureIds: s.featureIds.map((fId) => featureIdMap.get(fId) ?? fId)
+  }));
+  const newFeatures = qaMap.features.map((f) => ({
+    ...f,
+    id: featureIdMap.get(f.id) ?? f.id,
+    sectionId: sectionIdMap.get(f.sectionId) ?? f.sectionId,
+    parentFeatureId: f.parentFeatureId ? featureIdMap.get(f.parentFeatureId) ?? f.parentFeatureId : undefined,
+    subFeatureIds: f.subFeatureIds.map((id) => featureIdMap.get(id) ?? id),
+    workflowIds: f.workflowIds.map((wId) => workflowIdMap.get(wId) ?? wId),
+    entryPoints: f.entryPoints.map((ep) => ({
+      ...ep,
+      sourceFeatureId: ep.sourceFeatureId ? featureIdMap.get(ep.sourceFeatureId) ?? ep.sourceFeatureId : undefined
+    }))
+  }));
+  const newWorkflows = qaMap.workflows.map((w) => ({
+    ...w,
+    id: workflowIdMap.get(w.id) ?? w.id,
+    featureId: featureIdMap.get(w.featureId) ?? w.featureId,
+    componentIds: w.componentIds.map((cId) => componentIdMap.get(cId) ?? cId),
+    steps: w.steps.map((step) => ({
+      ...step,
+      componentIds: step.componentIds.map((cId) => componentIdMap.get(cId) ?? cId)
+    }))
+  }));
+  const newComponents = qaMap.components.map((c) => ({
+    ...c,
+    id: componentIdMap.get(c.id) ?? c.id,
+    referencedByWorkflows: c.referencedByWorkflows.map((wId) => workflowIdMap.get(wId) ?? wId)
+  }));
+  const newScenarios = qaMap.scenarios.map((s) => ({
+    ...s,
+    featureId: featureIdMap.get(s.featureId) ?? s.featureId,
+    workflowId: workflowIdMap.get(s.workflowId) ?? s.workflowId,
+    componentIds: s.componentIds.map((cId) => componentIdMap.get(cId) ?? cId)
+  }));
+  return {
+    ...qaMap,
+    sections: newSections,
+    features: newFeatures,
+    workflows: newWorkflows,
+    components: newComponents,
+    scenarios: newScenarios
+  };
+}
 
 // src/commands/analyze.ts
 var ENV_KEY = {
@@ -7561,7 +7637,8 @@ async function ensureApiKey(provider) {
   }
 }
 function registerAnalyze(program2) {
-  program2.command("analyze [input]").description("Analyze AST scan with AI to generate QA map (features, workflows, scenarios)").option("--output <file>", "Write QA map to specific file").option("--skip-scenarios", "Only run feature analysis (skip scenario generation)").action(async (inputArg, opts) => {
+  program2.command("analyze [input]").description("Analyze AST scan with AI to generate QA map (features, workflows, scenarios)").option("--output <file>", "Write QA map to specific file").option("--skip-scenarios", "Only run feature analysis (skip scenario generation)").option("--schema-version <version>", "Output schema version (2 or 3)", "3").action(async (inputArg, opts) => {
+    const schemaVersion = parseInt(opts?.schemaVersion ?? "3", 10);
     const ctx = await resolveCommandContext(program2);
     const root = ctx.paths.projectRoot;
     let inputPath;
@@ -7597,6 +7674,10 @@ function registerAnalyze(program2) {
     if (!hasKey)
       return;
     const spinner = createSpinner();
+    if (schemaVersion === 3) {
+      await runV3Analysis(ctx, ast, outputPath, prevQAMap, affected, spinner, opts);
+      return;
+    }
     spinner.start("Stage 2a: Identifying features...");
     const featureAgent = loadAgent("feature-analyzer-agent", ctx.config);
     const featureResponse = await callLLM({
@@ -7745,6 +7826,166 @@ function registerAnalyze(program2) {
     success(`QA map written to ${outputPath}`);
   });
 }
+async function runV3Analysis(ctx, ast, outputPath, _prevQAMap, _affected, spinner, opts) {
+  spinner.start("Stage 2a: Identifying sections and features (V3)...");
+  const featureAgent = loadAgent("feature-analyzer-agent-v3", ctx.config);
+  const featureResponse = await callLLM({
+    provider: ctx.provider,
+    model: ctx.model ?? featureAgent.config.model,
+    systemPrompt: featureAgent.systemPrompt,
+    userMessage: JSON.stringify({ ast }),
+    maxTokens: featureAgent.config.maxTokens,
+    temperature: featureAgent.config.temperature,
+    jsonMode: true
+  });
+  spinner.stop();
+  const featureMap = JSON.parse(extractJSON(featureResponse.content));
+  if (!featureMap?.features || !featureMap?.sections) {
+    error("Feature analysis failed: invalid response (missing features or sections)");
+    process.exit(1);
+  }
+  const sections = featureMap.sections;
+  const features = featureMap.features;
+  const baseComponents = featureMap.components ?? [];
+  success(`Identified ${sections.length} sections, ${features.length} features, ${baseComponents.length} components`);
+  spinner.start(`Stage 2b: Mapping DAG workflows for ${features.length} feature(s)...`);
+  const workflowTasks = features.map((feature) => {
+    const featureComponents = baseComponents.filter((c) => c.sourceFiles.some((sf) => feature.sourceFiles.includes(sf)));
+    const featureRoutes = ast.routes.filter((r) => feature.routes.some((fr) => r.path.startsWith(fr.split("/").slice(0, 3).join("/"))));
+    const featureForms = (ast.forms ?? []).filter((f) => feature.sourceFiles.includes(f.filePath));
+    return {
+      agentName: "workflow-agent-v3",
+      userMessage: JSON.stringify({ feature, components: featureComponents, routes: featureRoutes, forms: featureForms }),
+      config: ctx.config,
+      provider: ctx.provider,
+      model: ctx.model
+    };
+  });
+  const workflowResults = await runAgentsInParallel(workflowTasks, 4);
+  spinner.stop();
+  let allWorkflows = workflowResults.flatMap((r) => r.workflows ?? []);
+  spinner.start("Validating workflow DAGs...");
+  const validatedWorkflows = [];
+  for (const wf of allWorkflows) {
+    const dagResult = isDAGValid(wf.steps, wf.edges, wf.entryStepIds);
+    if (dagResult.valid) {
+      validatedWorkflows.push(wf);
+    } else {
+      warn(`Workflow "${wf.name}" has invalid DAG: ${dagResult.errors.join("; ")}. Falling back to linear chain.`);
+      const linear = linearToDAG(wf.steps);
+      validatedWorkflows.push({
+        ...wf,
+        steps: linear.steps,
+        edges: linear.edges,
+        entryStepIds: linear.entryStepIds
+      });
+    }
+  }
+  spinner.stop();
+  allWorkflows = validatedWorkflows;
+  success(`Mapped ${allWorkflows.length} workflows with DAG structure`);
+  const workflowsByFeature = new Map;
+  for (const wf of allWorkflows) {
+    const ids = workflowsByFeature.get(wf.featureId) ?? [];
+    ids.push(wf.id);
+    workflowsByFeature.set(wf.featureId, ids);
+  }
+  for (const feature of features) {
+    const wfIds = workflowsByFeature.get(feature.id);
+    if (wfIds)
+      feature.workflowIds = wfIds;
+  }
+  const formComponents = baseComponents.filter((c) => c.type === "form");
+  if (formComponents.length > 0 && (ast.forms ?? []).length > 0) {
+    spinner.start(`Stage 2c: Enriching ${formComponents.length} form component(s)...`);
+    const inputTasks = features.map((feature) => {
+      const featureFormComponents = formComponents.filter((c) => c.sourceFiles.some((sf) => feature.sourceFiles.includes(sf)));
+      const featureForms = (ast.forms ?? []).filter((f) => feature.sourceFiles.includes(f.filePath));
+      if (featureFormComponents.length === 0)
+        return null;
+      return {
+        agentName: "input-agent",
+        userMessage: JSON.stringify({ featureId: feature.id, components: featureFormComponents, forms: featureForms }),
+        config: ctx.config,
+        provider: ctx.provider,
+        model: ctx.model
+      };
+    }).filter((t) => t !== null);
+    if (inputTasks.length > 0) {
+      try {
+        const inputResults = await runAgentsInParallel(inputTasks, 4);
+        for (const result of inputResults) {
+          for (const enriched of result.components ?? []) {
+            const idx = baseComponents.findIndex((c) => c.id === enriched.id);
+            if (idx !== -1) {
+              baseComponents[idx] = { ...baseComponents[idx], ...enriched };
+            }
+          }
+        }
+      } catch {
+        warn("Input enrichment failed (non-critical), continuing with base components");
+      }
+    }
+    spinner.stop();
+  }
+  if (opts?.skipScenarios) {
+    const finalPayload2 = {
+      schemaVersion: 3,
+      sections,
+      features,
+      workflows: allWorkflows,
+      components: baseComponents,
+      scenarios: [],
+      metadata: ast.git ? { git: ast.git } : undefined
+    };
+    const normalizedPayload2 = normalizeIdsV3(finalPayload2);
+    writeFile(outputPath, JSON.stringify(normalizedPayload2, null, 2));
+    success(`V3 QA map written to ${outputPath}`);
+    return;
+  }
+  spinner.start(`Stage 3: Generating scenarios for ${features.length} feature(s)...`);
+  const scenarioTasks = features.map((feature) => {
+    const featureWorkflows = allWorkflows.filter((w) => w.featureId === feature.id);
+    const featureComponents = baseComponents.filter((c) => c.referencedByWorkflows.some((wfId) => featureWorkflows.map((w) => w.id).includes(wfId)));
+    return {
+      agentName: "scenario-planner-agent-v3",
+      userMessage: JSON.stringify({
+        features: [feature],
+        workflows: featureWorkflows,
+        components: featureComponents
+      }),
+      config: ctx.config,
+      provider: ctx.provider,
+      model: ctx.model
+    };
+  });
+  const scenarioResults = await runAgentsInParallel(scenarioTasks, 4);
+  spinner.stop();
+  const allScenarios = scenarioResults.flatMap((r) => r.scenarios ?? []);
+  success(`Generated ${allScenarios.length} scenarios`);
+  const finalPayload = {
+    schemaVersion: 3,
+    sections,
+    features,
+    workflows: allWorkflows,
+    components: baseComponents,
+    scenarios: allScenarios,
+    metadata: ast.git ? { git: ast.git } : undefined
+  };
+  const normalizedPayload = normalizeIdsV3(finalPayload);
+  const validation = validateQAMapV3(normalizedPayload);
+  if (!validation.valid) {
+    warn("V3 QA map has validation issues:");
+    for (const err of validation.errors)
+      warn(`  - ${err}`);
+  }
+  if (validation.warnings.length > 0) {
+    for (const w of validation.warnings)
+      info(`  ⚠ ${w}`);
+  }
+  writeFile(outputPath, JSON.stringify(normalizedPayload, null, 2));
+  success(`V3 QA map written to ${outputPath}`);
+}
 
 // src/commands/auth.ts
 function registerAuth(program2) {
@@ -8060,7 +8301,9 @@ import { join as join7 } from "node:path";
 
 // src/scanner/push.ts
 async function pushToApi(payload, apiUrl, apiKey) {
-  const response = await fetch(apiUrl, {
+  const isV3 = payload.schemaVersion === 3;
+  const url = isV3 ? apiUrl.replace("/v2/push", "/v3/push") : apiUrl.replace("/v3/push", "/v2/push");
+  const response = await fetch(url, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -8092,7 +8335,9 @@ function registerPush(program2) {
       error(`QA map not found: ${inputPath}`);
       process.exit(1);
     }
-    const payload = JSON.parse(readFile(inputPath));
+    const raw = JSON.parse(readFile(inputPath));
+    const isV3 = raw.schemaVersion === 3;
+    const payload = raw;
     if (opts?.commitSha) {
       payload.commitSha = opts.commitSha;
     }
@@ -8109,14 +8354,16 @@ function registerPush(program2) {
         payload.commitSha = gitMeta.commitSha;
       }
     }
-    info(`Pushing: ${payload.features.length} features, ${payload.workflows.length} workflows, ${payload.scenarios.length} scenarios`);
+    const sectionCount = isV3 ? payload.sections.length : 0;
+    info(`Pushing (V${isV3 ? 3 : 2}): ${sectionCount ? sectionCount + " sections, " : ""}${payload.features.length} features, ${payload.workflows.length} workflows, ${payload.scenarios.length} scenarios`);
+    const pushEndpoint = isV3 ? "/api/cli/push-v3" : "/api/cli/push";
     try {
       const { AuthClient } = await import("./index-fbvbnntc.js");
       const client = AuthClient.fromSession();
       if (client) {
         const spinner2 = createSpinner();
         spinner2.start("Pushing via authenticated session...");
-        const result2 = await client.post("/api/cli/push", payload);
+        const result2 = await client.post(pushEndpoint, payload);
         spinner2.stop();
         success("Push successful!");
         info(`  Version: ${result2.version} (schema v${result2.schemaVersion})`);