@sun-asterisk/sungen 3.0.0 → 3.1.0

package/src/cli/commands/ingest.ts

@@ -0,0 +1,141 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import * as fs from 'fs';
+import { parseLegacyFile, listSheets, baselineAudit, BaselineReport, LegacyInventory, inventoryToGherkin, reconcileViewpoints, renderViewpointOverview, fetchGoogleSheet } from '../../ingest';
+
+function renderInventoryMd(inv: LegacyInventory, r: BaselineReport): string {
+  const lines: string[] = [];
+  lines.push(`# Legacy Testcase Inventory — ${inv.source.file}`, '');
+  lines.push(`Total testcases: **${r.total}**`, '');
+  lines.push('## Sheets', '', '| Sheet | Type | Rows |', '|---|---|---|');
+  for (const s of r.sheets) lines.push(`| ${s.name} | ${s.type} | ${s.rows} |`);
+  lines.push('', '## By category', '');
+  for (const [k, v] of Object.entries(r.byCategory).sort((a, b) => b[1] - a[1])) lines.push(`- ${k}: ${v}`);
+  lines.push('', `Depth: **${(r.depthRatio * 100).toFixed(0)}%** (${r.deepCount}/${r.total} assert a concrete expected value)`, '');
+  return lines.join('\n');
+}
+
+function render(inv: LegacyInventory, r: BaselineReport): void {
+  const L = console.log;
+  const pct = (x: number) => (r.total ? Math.round((x / r.total) * 100) : 0);
+  L('');
+  L(`━━━ Legacy Ingest — ${inv.source.file} ━━━`);
+  L('');
+  L(`  Sheets:`);
+  for (const s of r.sheets) L(`    • ${s.name} — ${s.type} (${s.rows})`);
+  L('');
+  L(`  TOTAL testcases: ${r.total}`);
+  L('');
+  L('  ── QA baseline ──');
+  L(`  By category: ${Object.entries(r.byCategory).sort((a, b) => b[1] - a[1]).slice(0, 12).map(([k, v]) => `${k}=${v}`).join('  ')}`);
+  L(`  By priority: ${Object.entries(r.byPriority).map(([k, v]) => `${k}=${v}`).join('  ')}`);
+  L(`  By result:   ${Object.entries(r.byResult).map(([k, v]) => `${k}=${v}`).join('  ')}`);
+  L(`  Depth:       ${r.deepCount}/${r.total} (${(r.depthRatio * 100).toFixed(0)}%) assert a concrete expected value → convert to DEEP Gherkin`);
+  L(`  Duplicates:  ${r.duplicateClusters} same-shape cluster(s), ${r.exactDuplicates} likely exact`);
+  L('');
+  L('  ── Capability Plan (which driver, if any) ──');
+  L(`    UI automatable      : ${r.reasons.ui}  (${pct(r.reasons.ui)}%)`);
+  L(`    cross-screen → flow : ${r.reasons.crossScreen}  (${pct(r.reasons.crossScreen)}%)`);
+  L(`    capability-manual   : ${r.reasons.capabilityManual}  (${pct(r.reasons.capabilityManual)}%)`);
+  L(`    keep-manual         : ${r.reasons.keepManual}  (${pct(r.reasons.keepManual)}%)`);
+  if (r.reasons.driverCandidates.length)
+    L(`    driver candidates   : ${r.reasons.driverCandidates.map((d) => `${d.driver}×${d.count}`).join('  ')}`);
+  else
+    L(`    driver candidates   : none (no capability-manual at scale → no driver justified)`);
+  L('');
+}
+
+export function registerIngestCommand(program: Command): void {
+  program
+    .command('ingest')
+    .description('Ingest a legacy manual testcase workbook (CSV/XLSX/JSON-bundle) → normalized inventory + QA baseline audit')
+    .option('--legacy <file...>', 'Path(s) to the legacy testcase file(s): .csv, .xlsx, or a .json sheet-bundle')
+    .option('--gsheet <urlOrId>', 'Fetch a Google Sheet (all tabs) under YOUR Google identity (ADC, read-only) → bundle. Needs: npm i googleapis + gcloud auth application-default login')
+    .option('-s, --screen <name>', 'Screen name (output goes under qa/screens/<name>/requirements/legacy/)')
+    .option('--out <dir>', 'Output directory (overrides the default screen path)')
+    .option('--sheets <names>', 'Comma-separated tab names to ingest (default: all). Workbooks carry many tabs.')
+    .option('--list-sheets', 'List the tabs + detected type (testcase/viewpoint-matrix/ui-checklist) and exit')
+    .option('--emit-gherkin', 'Also emit a traceable Gherkin DRAFT (.legacy-draft.feature) + trace map (P-B)')
+    .option('--json', 'Print the raw inventory + baseline JSON')
+    .action(async (options) => {
+      try {
+        if (!options.legacy && !options.gsheet) throw new Error('Provide --legacy <file...> or --gsheet <url|id>');
+
+        const outDir = options.out
+          ? path.resolve(process.cwd(), options.out)
+          : options.screen
+            ? path.join(process.cwd(), 'qa', 'screens', options.screen, 'requirements', 'legacy')
+            : path.join(process.cwd(), '.sungen', 'legacy');
+        fs.mkdirSync(outDir, { recursive: true });
+
+        let files: string[];
+        if (options.gsheet) {
+          // Fetch as the user (not AI) — bypasses the AI-context DLP legitimately.
+          const bundle = await fetchGoogleSheet(String(options.gsheet));
+          const bundlePath = path.join(outDir, 'bundle.json');
+          fs.writeFileSync(bundlePath, JSON.stringify(bundle, null, 0));
+          console.log(`  Fetched Google Sheet "${bundle.source}" → ${bundle.sheets.length} tab(s) → ${path.relative(process.cwd(), bundlePath)}`);
+          files = [bundlePath];
+        } else {
+          files = (Array.isArray(options.legacy) ? options.legacy : [options.legacy])
+            .map((f: string) => path.resolve(process.cwd(), f));
+          for (const f of files) if (!fs.existsSync(f)) throw new Error(`File not found: ${f}`);
+        }
+
+        if (options.listSheets) {
+          const sheets = await listSheets(files);
+          console.log('');
+          console.log('  Tabs found:');
+          for (const s of sheets) console.log(`    • ${s.name} — ${s.type} (${s.rows} rows)`);
+          console.log('');
+          console.log(`  Ingest the testcase tab(s) with: --sheets "${sheets.filter((s) => s.type === 'testcase').map((s) => s.name).join(',')}"`);
+          console.log('');
+          return;
+        }
+
+        const onlySheets: string[] | undefined = options.sheets ? String(options.sheets).split(',') : undefined;
+        const inv = await parseLegacyFile(files, onlySheets);
+        const report = baselineAudit(inv);
+        fs.writeFileSync(path.join(outDir, 'inventory.json'), JSON.stringify({ inventory: inv, baseline: report }, null, 2));
+        fs.writeFileSync(path.join(outDir, 'inventory.md'), renderInventoryMd(inv, report));
+
+        let convert;
+        let recon;
+        if (options.emitGherkin) {
+          const featureName = options.screen || (files.length === 1 ? path.basename(files[0]).replace(/\.[^.]+$/, '') : 'legacy');
+          convert = inventoryToGherkin(inv, featureName);
+          fs.writeFileSync(path.join(outDir, `${featureName}.legacy-draft.feature`), convert.feature);
+          fs.writeFileSync(path.join(outDir, 'legacy-trace.json'), JSON.stringify(convert.trace, null, 2));
+          // Viewpoint reconciliation: legacy coverage vs catalog → blind-spots (P-C)
+          recon = reconcileViewpoints(inv);
+          fs.writeFileSync(path.join(outDir, 'test-viewpoint.draft.md'), renderViewpointOverview(featureName, recon));
+        }
+
+        if (options.json) console.log(JSON.stringify({ inventory: inv, baseline: report, convert, reconciliation: recon }, null, 2));
+        else {
+          render(inv, report);
+          if (convert) {
+            const g = convert.gap;
+            console.log('  ── Gherkin draft (P-B) ──');
+            console.log(`    ${g.total} scenario(s) drafted → ui=${g.ui} · cross-screen=${g.crossScreen} · @manual(capability)=${g.manualCapability} · @manual(keep)=${g.manualKeep}`);
+            if (g.noExpected) console.log(`    ⚠ ${g.noExpected} testcase(s) without an Expected → needs review`);
+            console.log(`    Draft: ${path.relative(process.cwd(), outDir)}/*.legacy-draft.feature (refine via /sungen:create-test)`);
+          }
+          if (recon) {
+            console.log('  ── Viewpoint reconciliation (legacy vs catalog) ──');
+            console.log(`    page-type: ${recon.pageType ?? 'unknown'} · legacy covers ${recon.themesCovered}/${recon.themesTotal} catalog themes (${(recon.coverageRatio * 100).toFixed(0)}%)`);
+            if (recon.blindSpots.length)
+              console.log(`    ⚠ BLIND-SPOTS (catalog expects, legacy lacks): ${recon.blindSpots.map((b) => `${b.theme}[${b.status}]`).join(', ')}`);
+            else
+              console.log(`    ✓ no catalog blind-spots — legacy covers the expected themes`);
+            console.log(`    Draft viewpoint: ${path.relative(process.cwd(), outDir)}/test-viewpoint.draft.md → seed /sungen:create-test`);
+          }
+          console.log(`  Inventory: ${path.relative(process.cwd(), outDir)}/inventory.json`);
+          console.log('');
+        }
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/index.ts

@@ -15,6 +15,8 @@ import { registerFigmaCommand } from './commands/figma';
 import { registerAddFlowCommand } from './commands/add-flow';
 import { registerDashboardCommand } from './commands/dashboard';
 import { registerAuditCommand } from './commands/audit';
+import { registerIngestCommand } from './commands/ingest';
+import { registerEvalCommand } from './commands/eval';
 import { registerManifestCommand } from './commands/manifest';
 import { registerLedgerCommand } from './commands/ledger';
 import { registerFeedbackCommand } from './commands/feedback';
@@ -60,6 +62,8 @@ async function main() {
   registerBlindspotCommand(program);
   registerCapabilityCommand(program);
   registerFlowCheckCommand(program);
+  registerIngestCommand(program);
+  registerEvalCommand(program);
 
   await program.parseAsync(process.argv);
 }