vibepro 0.1.0-alpha.0

package/src/regression-risk-scanner.js

@@ -0,0 +1,146 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  extractGraphNodeSourceFile,
+  getEdgeEndpoint,
+  normalizeGraphEdges,
+  normalizeGraphPath
+} from './graph-context.js';
+import { loadCoverage } from './coverage-report.js';
+import { getWorkspaceDir } from './workspace.js';
+
+// Regression-risk scanner: blast-radius core, optionally sharpened by coverage.
+//
+// Primary signal: module-level fan-in derived from the Graphify call graph. A
+// module called by many distinct other modules has a large blast radius —
+// changing it risks regressions in every caller. This is IMPACT risk, not defect
+// probability: a static call graph cannot tell you a change is buggy, only how
+// far its effects can reach. We name it accordingly and never claim prediction.
+//
+// Secondary signal (optional): real line coverage from the project's own tooling
+// (c8/istanbul/lcov). When present, a high-blast-radius module with low coverage
+// is escalated to `critical` — large reach AND a thin safety net is the genuine
+// regression trap. Coverage is deliberately NOT inferred from the call graph:
+// dogfooding VibePro showed static call-graph test-reachability mislabels
+// CLI/subprocess-driven coverage as untested. When no coverage report exists we
+// degrade cleanly to fan-in-only scoring with identical behavior to before.
+
+const DEFAULT_HIGH_FAN_IN = 10;
+const DEFAULT_MODERATE_FAN_IN = 5;
+const DEFAULT_LOW_COVERAGE = 0.5;
+const DEFAULT_TOP = 20;
+const CALL_RELATIONS = new Set(['calls', 'call', 'invokes', 'uses']);
+
+export async function scanRegressionRisk(repoRoot, options = {}) {
+  const root = path.resolve(repoRoot);
+  const graphPath = path.join(getWorkspaceDir(root), 'graphify', 'graph.json');
+
+  let graph;
+  try {
+    graph = JSON.parse(await readFile(graphPath, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {
+        status: 'skipped',
+        reason:
+          'Regression-risk scanning needs a Graphify call graph at .vibepro/graphify/graph.json. ' +
+          'Graphify is optional: run a story diagnosis or import with --run-graphify / --from <graphify-out> first.',
+        hotspots: [],
+        summary: { scored_modules: 0, high: 0, moderate: 0 }
+      };
+    }
+    throw error;
+  }
+
+  const loaded = await loadCoverage(root, { file: options.coverageFile });
+  return analyzeRegressionRisk(graph, {
+    ...options,
+    coverage: loaded?.coverage ?? null,
+    coverageSource: loaded?.source ?? null
+  });
+}
+
+// Pure analysis over a loaded graph. Exported for unit testing without disk I/O.
+export function analyzeRegressionRisk(graph, options = {}) {
+  const includePrefixes = options.includePrefixes ?? ['src/'];
+  const highFanIn = options.highFanIn ?? DEFAULT_HIGH_FAN_IN;
+  const moderateFanIn = options.moderateFanIn ?? DEFAULT_MODERATE_FAN_IN;
+  const lowCoverage = options.lowCoverage ?? DEFAULT_LOW_COVERAGE;
+  const coverage = options.coverage ?? null;
+  const hasCoverage = coverage instanceof Map && coverage.size > 0;
+  const top = options.top ?? DEFAULT_TOP;
+
+  const fileById = new Map();
+  for (const node of graph?.nodes ?? []) {
+    if (!node || typeof node.id !== 'string') continue;
+    const sourceFile = extractGraphNodeSourceFile(node);
+    if (sourceFile) fileById.set(node.id, normalizeGraphPath(sourceFile));
+  }
+
+  const { edges } = normalizeGraphEdges(graph);
+  const callers = new Map(); // module -> Set of caller modules (fan-in)
+  const callees = new Map(); // module -> Set of callee modules (fan-out)
+  const inScope = (file) => Boolean(file) && includePrefixes.some((prefix) => file.startsWith(prefix));
+  const add = (map, key, value) => {
+    if (!map.has(key)) map.set(key, new Set());
+    map.get(key).add(value);
+  };
+
+  for (const edge of edges) {
+    if (edge?.relation && !CALL_RELATIONS.has(edge.relation)) continue;
+    const sourceFile = fileById.get(getEdgeEndpoint(edge, 'source'));
+    const targetFile = fileById.get(getEdgeEndpoint(edge, 'target'));
+    if (!sourceFile || !targetFile || sourceFile === targetFile) continue; // cross-module only
+    if (inScope(targetFile)) add(callers, targetFile, sourceFile);
+    if (inScope(sourceFile)) add(callees, sourceFile, targetFile);
+  }
+
+  const hotspots = [...callers.entries()]
+    .map(([file, callerSet]) => {
+      const fanIn = callerSet.size;
+      const riskTier = fanIn >= highFanIn ? 'high' : fanIn >= moderateFanIn ? 'moderate' : 'low';
+      const coveragePct = hasCoverage && coverage.has(file)
+        ? Number((coverage.get(file) * 100).toFixed(1))
+        : null;
+      // critical = large blast radius AND a thin (known) safety net.
+      const priority = riskTier === 'high' && coveragePct !== null && coveragePct < lowCoverage * 100
+        ? 'critical'
+        : riskTier;
+      return {
+        file,
+        fan_in: fanIn,
+        fan_out: callees.get(file)?.size ?? 0,
+        risk_tier: riskTier,
+        coverage_pct: coveragePct,
+        priority
+      };
+    })
+    .sort((a, b) => priorityRank(b) - priorityRank(a) || b.fan_in - a.fan_in || a.file.localeCompare(b.file));
+
+  const high = hotspots.filter((h) => h.risk_tier === 'high').length;
+  const moderate = hotspots.filter((h) => h.risk_tier === 'moderate').length;
+  const critical = hotspots.filter((h) => h.priority === 'critical').length;
+
+  // With coverage data, a well-tested hub is no longer a review trigger; only
+  // high-blast-radius + low-coverage (critical) escalates. Without coverage,
+  // behavior is unchanged: any high-blast-radius module triggers review.
+  const status = hasCoverage ? (critical > 0 ? 'needs_review' : 'pass') : (high > 0 ? 'needs_review' : 'pass');
+
+  return {
+    status,
+    hotspots: hotspots.slice(0, top),
+    summary: {
+      scored_modules: hotspots.length,
+      high,
+      moderate,
+      critical,
+      coverage_source: options.coverageSource ?? (hasCoverage ? 'provided' : null),
+      thresholds: { high_fan_in: highFanIn, moderate_fan_in: moderateFanIn, low_coverage_pct: lowCoverage * 100 }
+    }
+  };
+}
+
+function priorityRank(hotspot) {
+  return { critical: 3, high: 2, moderate: 1, low: 0 }[hotspot.priority] ?? 0;
+}

package/src/repo-status.js

@@ -0,0 +1,266 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { runDoctor } from './doctor.js';
+import { DEFAULT_BRAINBASE_STORIES, getWorkspaceDir, MANIFEST_FILE } from './workspace.js';
+
+export async function getRepoStatus(repoRoot) {
+  const root = path.resolve(repoRoot);
+  const workspaceDir = getWorkspaceDir(root);
+  const configPath = path.join(workspaceDir, 'config.json');
+  const manifestPath = path.join(workspaceDir, MANIFEST_FILE);
+  const initialized = await exists(configPath) && await exists(manifestPath);
+
+  if (!initialized) {
+    return {
+      initialized: false,
+      repo_root: root,
+      workspace: '.vibepro',
+      current_story_id: null,
+      active_stories: [],
+      latest_run: null,
+      selected_story_latest_run: null,
+      gate_status: null,
+      finding_count: 0,
+      artifacts: {},
+      next_commands: [`vibepro init ${root}`]
+    };
+  }
+
+  const configRead = await readJsonWithStatus(configPath, 'config');
+  const manifestRead = await readJsonWithStatus(manifestPath, 'manifest');
+  if (!configRead.ok || !manifestRead.ok) {
+    const issues = [configRead, manifestRead]
+      .filter((item) => !item.ok)
+      .map((item) => ({
+        id: `VP-STATUS-${item.label.toUpperCase()}-INVALID`,
+        severity: 'block',
+        file: toWorkspacePath(root, item.filePath),
+        detail: `${item.label} JSON is invalid: ${item.error}`
+      }));
+    return {
+      initialized: true,
+      repo_root: root,
+      workspace: '.vibepro',
+      workspace_status: 'needs_repair',
+      current_story_id: null,
+      active_stories: [],
+      latest_run: null,
+      selected_story_latest_run: null,
+      gate_status: 'blocked',
+      finding_count: issues.length,
+      artifacts: {},
+      doctor: {
+        overall_status: 'needs_repair',
+        check_count: issues.length,
+        blocking_check_ids: issues.map((issue) => issue.id),
+        next_actions: [{
+          command: `repair ${toWorkspacePath(root, configRead.ok ? manifestPath : configPath)}`,
+          reason: 'VibePro workspace JSON must be valid before status, diagnose, or PR gates can be trusted.'
+        }]
+      },
+      issues,
+      next_commands: [
+        `repair ${toWorkspacePath(root, configRead.ok ? manifestPath : configPath)}`,
+        `vibepro status ${root} --json`
+      ]
+    };
+  }
+
+  const config = configRead.value;
+  const manifest = manifestRead.value;
+  const currentStoryId = config.brainbase?.current_story_id ?? null;
+  const activeStories = prioritizeStory(normalizeStatusStories(config.brainbase?.stories), currentStoryId);
+  const selectedStory = activeStories.find((story) => story.story_id === currentStoryId) ?? null;
+  const runs = Array.isArray(manifest.runs) ? manifest.runs : [];
+  const latestRun = findRun(runs, manifest.latest_run) ?? runs[0] ?? null;
+  const selectedStoryLatestRun = selectedStory
+    ? findLatestStoryRun(manifest, runs, selectedStory.story_id)
+    : null;
+  const primaryRun = selectedStoryLatestRun ?? latestRun;
+  const evidence = primaryRun ? await readRunEvidence(root, primaryRun) : null;
+  const findings = Array.isArray(evidence?.findings) ? evidence.findings : [];
+  const doctor = await runDoctor(root, { writeArtifacts: false });
+
+  return {
+    initialized: true,
+    repo_root: root,
+    workspace: '.vibepro',
+    current_story_id: currentStoryId,
+    active_stories: activeStories,
+    latest_run: latestRun,
+    selected_story_latest_run: selectedStoryLatestRun,
+    gate_status: primaryRun?.gate_status ?? evidence?.gates?.[0]?.status ?? null,
+    finding_count: findings.length,
+    artifacts: primaryRun?.artifacts ?? {},
+    doctor: {
+      overall_status: doctor.overall_status,
+      check_count: doctor.checks.length,
+      blocking_check_ids: doctor.checks
+        .filter((check) => ['fixable', 'manual'].includes(check.status))
+        .map((check) => check.id),
+      next_actions: doctor.next_actions
+    },
+    next_commands: buildNextCommands(root, {
+      activeStories,
+      selectedStory,
+      latestRun,
+      selectedStoryLatestRun,
+      doctor
+    })
+  };
+}
+
+export function renderRepoStatus(status) {
+  const latestRun = status.latest_run;
+  const selectedStoryRun = status.selected_story_latest_run;
+  return `# VibePro Status
+
+| 項目 | 内容 |
+|------|------|
+| Initialized | ${status.initialized ? 'yes' : 'no'} |
+| Workspace | ${status.workspace} |
+| Workspace Status | ${status.workspace_status ?? 'ok'} |
+| Selected Story | ${status.current_story_id ?? '-'} |
+| Active Stories | ${status.active_stories.length} |
+| Latest Run | ${latestRun?.run_id ?? '-'} |
+| Selected Story Latest Run | ${selectedStoryRun?.run_id ?? '-'} |
+| Gate | ${status.gate_status ?? '-'} |
+| Findings | ${status.finding_count} |
+| Doctor | ${status.doctor?.overall_status ?? '-'} |
+
+## Active Stories
+
+${status.active_stories.length === 0 ? '- なし' : status.active_stories.map((story) => `- ${story.story_id}: ${story.title} / view:${story.view ?? '-'} / period:${story.period ?? '-'}`).join('\n')}
+
+## Artifacts
+
+${Object.entries(status.artifacts).length === 0 ? '- なし' : Object.entries(status.artifacts).map(([key, value]) => `- ${key}: ${value}`).join('\n')}
+
+## Doctor
+
+${renderDoctorStatus(status.doctor)}
+
+## Next Commands
+
+${status.next_commands.map((command) => `- ${command}`).join('\n')}
+`;
+}
+
+async function exists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+async function readJsonWithStatus(filePath, label) {
+  try {
+    return {
+      ok: true,
+      label,
+      filePath,
+      value: JSON.parse(await readFile(filePath, 'utf8'))
+    };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return {
+        ok: false,
+        label,
+        filePath,
+        error: error.message
+      };
+    }
+    throw error;
+  }
+}
+
+function toWorkspacePath(repoRoot, filePath) {
+  return path.relative(repoRoot, filePath).split(path.sep).join('/');
+}
+
+function findRun(runs, runId) {
+  if (!runId) return null;
+  return runs.find((run) => run.run_id === runId) ?? null;
+}
+
+function prioritizeStory(stories, storyId) {
+  if (!storyId) return stories;
+  const selected = stories.find((story) => story.story_id === storyId);
+  if (!selected) return stories;
+  return [selected, ...stories.filter((story) => story.story_id !== storyId)];
+}
+
+function normalizeStatusStories(stories) {
+  const sourceStories = Array.isArray(stories) ? stories : DEFAULT_BRAINBASE_STORIES;
+  return sourceStories
+    .filter((story) => story.status !== 'archived')
+    .map((story) => ({
+      story_id: story.story_id,
+      title: story.title,
+      ssot: story.ssot ?? 'NocoDB',
+      status: story.status ?? 'active',
+      horizon: story.horizon ?? null,
+      view: typeof story.view === 'string' ? story.view : null,
+      period: typeof story.period === 'string' ? story.period : null,
+      started_at: story.started_at ?? null,
+      due_at: story.due_at ?? null
+    }));
+}
+
+function findLatestStoryRun(manifest, runs, storyId) {
+  const latestStoryRunId = manifest.latest_run_by_story?.[storyId] ?? null;
+  return findRun(runs, latestStoryRunId)
+    ?? runs.find((run) => run.story_id === storyId)
+    ?? null;
+}
+
+async function readRunEvidence(repoRoot, run) {
+  const evidencePath = run.artifacts?.evidence;
+  if (!evidencePath) return null;
+  try {
+    return JSON.parse(await readFile(path.resolve(repoRoot, evidencePath), 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function buildNextCommands(repoRoot, { activeStories, selectedStory, latestRun, selectedStoryLatestRun, doctor = null }) {
+  if (doctor && ['needs_maintenance', 'fixed'].includes(doctor.overall_status)) {
+    return doctor.next_commands?.length > 0
+      ? doctor.next_commands
+      : [`vibepro doctor ${repoRoot}`, `vibepro doctor ${repoRoot} --fix`];
+  }
+  if (activeStories.length === 0) {
+    return [`vibepro story add ${repoRoot} --id <story-id> --title "<title>"`];
+  }
+  if (!selectedStory) {
+    return [`vibepro story select ${repoRoot} --id ${activeStories[0].story_id}`];
+  }
+  if (!latestRun && !selectedStoryLatestRun) {
+    return [`vibepro story diagnose ${repoRoot} --id ${selectedStory.story_id} --run-graphify`];
+  }
+  return [
+    `vibepro story report ${repoRoot} --id ${selectedStory.story_id}`,
+    `vibepro brainbase ${repoRoot}`
+  ];
+}
+
+function renderDoctorStatus(doctor) {
+  if (!doctor) return '- なし';
+  const checks = doctor.blocking_check_ids?.length > 0
+    ? doctor.blocking_check_ids.join(', ')
+    : '-';
+  const actions = doctor.next_actions?.length > 0
+    ? doctor.next_actions.map((action) => `  - ${action.command}: ${action.reason}`).join('\n')
+    : '  - なし';
+  return `- overall: ${doctor.overall_status}
+- checks: ${doctor.check_count}
+- needs action: ${checks}
+- next actions:
+${actions}`;
+}

package/src/report-fingerprint.js

@@ -0,0 +1,188 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { preparePullRequest } from './pr-manager.js';
+import { readDrift, readInferredSpec } from './spec-store.js';
+import { readNarrative, REPORT_KINDS } from './report-store.js';
+import { getWorkspaceDir } from './workspace.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function buildReportFingerprint(repoRoot, options = {}) {
+  const root = path.resolve(repoRoot);
+  const kind = options.kind;
+  if (!REPORT_KINDS.has(kind)) {
+    throw new Error(`Unsupported report kind: ${kind}`);
+  }
+  const storyId = options.storyId ?? null;
+  if (!storyId) {
+    throw new Error('storyId is required');
+  }
+  if (kind === 'pr-body') {
+    return buildPrBodyFingerprint(root, { ...options, storyId });
+  }
+  throw new Error(`Unsupported report kind: ${kind}`);
+}
+
+async function buildPrBodyFingerprint(root, options) {
+  const storyId = options.storyId;
+  const prepare = await preparePullRequest(root, {
+    storyId,
+    baseRef: options.baseRef ?? null,
+    taskId: options.taskId ?? null,
+    groupId: options.groupId ?? null,
+    branchName: options.branchName ?? null,
+    allowExtraFiles: true
+  });
+
+  const preparation = prepare?.preparation ?? null;
+  const previousNarrative = await readNarrative(root, storyId, 'pr-body');
+  const inferredSpec = await readInferredSpec(root, storyId);
+  const drift = await readDrift(root, storyId);
+  const findings = await readLatestFindings(root, preparation?.latest_story_run);
+
+  const fingerprint = {
+    schema_version: '0.1.0',
+    kind: 'pr-body',
+    story_id: storyId,
+    generated_at: new Date().toISOString(),
+    story: preparation?.story ?? null,
+    pr_context: extractPrContextSummary(preparation),
+    file_groups: summarizeFileGroups(preparation?.file_groups),
+    gate_dag: summarizeGateDag(preparation?.pr_context?.gate_dag),
+    requirement_consistency: summarizeRequirement(preparation?.pr_context?.requirement_consistency),
+    inferred_spec: inferredSpec ? {
+      story_id: inferredSpec.story_id,
+      clauses: (inferredSpec.clauses ?? []).map((clause) => ({
+        id: clause.id,
+        type: clause.type,
+        statement: clause.statement
+      }))
+    } : null,
+    drift: drift ? {
+      status: drift.status,
+      summary: drift.summary,
+      items: (drift.items ?? []).map((item) => ({
+        id: item.id,
+        axis: item.axis,
+        clause_id: item.clause_id ?? null,
+        severity: item.severity,
+        title: item.title
+      }))
+    } : null,
+    findings: findings.map((finding) => ({
+      id: finding.id,
+      title: finding.title,
+      severity: finding.severity ?? null,
+      type: finding.type ?? null
+    })),
+    numerical_truth: buildNumericalTruth({ preparation, drift, requirementConsistency: preparation?.pr_context?.requirement_consistency }),
+    previous_narrative: previousNarrative,
+    schema_for_your_output: await readJson(path.join(__dirname, 'report-pr-body-schema.json')),
+    instructions: options.includeInstructions
+      ? await readFile(path.join(__dirname, 'report-pr-body-prompt-template.md'), 'utf8')
+      : null
+  };
+  fingerprint.inputs_digest = buildInputsDigest(fingerprint);
+  return fingerprint;
+}
+
+function extractPrContextSummary(preparation) {
+  if (!preparation) return null;
+  const ctx = preparation.pr_context ?? {};
+  return {
+    story_source_path: ctx.story_source?.path ?? null,
+    architecture_decision: ctx.architecture_decision ?? null,
+    change_summary: ctx.change_summary ?? [],
+    review_points: ctx.review_points ?? [],
+    risks: ctx.risks ?? [],
+    verification_commands: (ctx.verification_commands ?? []).map((entry) => ({
+      command: entry.command,
+      reason: entry.reason
+    }))
+  };
+}
+
+function summarizeFileGroups(fileGroups) {
+  if (!fileGroups) return null;
+  const summary = {};
+  for (const [key, value] of Object.entries(fileGroups)) {
+    summary[key] = {
+      count: value.count,
+      files: (value.files ?? []).slice(0, 12)
+    };
+  }
+  return summary;
+}
+
+function summarizeGateDag(gateDag) {
+  if (!gateDag) return null;
+  return {
+    overall_status: gateDag.overall_status ?? null,
+    nodes: (gateDag.nodes ?? []).map((node) => ({
+      id: node.id,
+      type: node.type,
+      status: node.status,
+      required: node.required ?? null,
+      reason: node.reason ?? null
+    }))
+  };
+}
+
+function summarizeRequirement(requirement) {
+  if (!requirement) return null;
+  return {
+    status: requirement.status,
+    summary: requirement.summary,
+    invariants: (requirement.invariants ?? []).map((entry) => ({ id: entry.id, text: entry.text })),
+    contradictions: (requirement.contradictions ?? []).map((entry) => ({ id: entry.id, title: entry.title })),
+    scenario_gaps: (requirement.scenario_gaps ?? []).map((entry) => ({ id: entry.id, title: entry.title }))
+  };
+}
+
+async function readLatestFindings(root, latestStoryRun) {
+  const evidencePath = latestStoryRun?.artifacts?.evidence;
+  if (!evidencePath) return [];
+  try {
+    const evidence = JSON.parse(await readFile(path.resolve(root, evidencePath), 'utf8'));
+    return Array.isArray(evidence.findings) ? evidence.findings.slice(0, 40) : [];
+  } catch {
+    return [];
+  }
+}
+
+function buildNumericalTruth({ preparation, drift, requirementConsistency }) {
+  const driftItems = drift?.items ?? [];
+  return {
+    changed_files_count: preparation?.git?.changed_files?.length ?? 0,
+    drift_total_count: driftItems.length,
+    drift_high_count: driftItems.filter((item) => item.severity === 'high').length,
+    requirement_invariant_count: requirementConsistency?.summary?.invariant_count ?? 0,
+    requirement_contradiction_count: requirementConsistency?.summary?.contradiction_count ?? 0,
+    acceptance_criteria_count: preparation?.pr_context?.story_source?.acceptance_criteria?.length ?? 0
+  };
+}
+
+function buildInputsDigest(fingerprint) {
+  return {
+    story_sha: sha256(fingerprint.story),
+    pr_context_sha: sha256(fingerprint.pr_context),
+    drift_sha: sha256(fingerprint.drift),
+    spec_sha: sha256(fingerprint.inferred_spec)
+  };
+}
+
+function sha256(value) {
+  const hash = createHash('sha256');
+  hash.update(JSON.stringify(value ?? null));
+  return `sha256:${hash.digest('hex')}`;
+}
+
+async function readJson(filePath) {
+  return JSON.parse(await readFile(filePath, 'utf8'));
+}
+
+// re-export utility for tests
+export { getWorkspaceDir };