@kunlv/atdc 1.0.0

package/src/evidence/ai-draft-metrics.js

@@ -0,0 +1,157 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function resolveMetricsDir(changeDir) {
+  const dir = path.join(changeDir, '.evidence', 'metrics');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function metricsFile(changeDir) {
+  return path.join(resolveMetricsDir(changeDir), 'ai-draft-metrics.json');
+}
+
+function captureDraftSnapshot(changeDir, label = 'pre-review') {
+  let diff;
+  try {
+    diff = execSync('git diff --unified=0 HEAD', { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
+  } catch {
+    diff = '';
+  }
+
+  if (!diff) {
+    return { label, totalLines: 0, aiLines: 0, adoptionRate: null, note: 'no unstaged changes' };
+  }
+
+  const lines = diff.split('\n');
+  let addedLines = 0;
+  let removedLines = 0;
+
+  for (const line of lines) {
+    if (line.startsWith('+') && !line.startsWith('+++')) addedLines++;
+    if (line.startsWith('-') && !line.startsWith('---')) removedLines++;
+  }
+
+  const totalChanged = addedLines + removedLines;
+
+  const snapshot = {
+    label,
+    timestamp: new Date().toISOString(),
+    addedLines,
+    removedLines,
+    totalChanged,
+  };
+
+  const fp = path.join(resolveMetricsDir(changeDir), `snapshot_${label}_${snapshot.timestamp.replace(/[:.]/g, '-')}.json`);
+  fs.writeFileSync(fp, JSON.stringify(snapshot, null, 2) + '\n');
+
+  storeMetric(changeDir, 'draft_snapshot', snapshot);
+
+  return snapshot;
+}
+
+function captureCommitDiff(changeDir, label = 'commit') {
+  let diff;
+  try {
+    diff = execSync('git diff --unified=0 HEAD~1 HEAD', { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
+  } catch {
+    try {
+      diff = execSync('git diff --unified=0 --cached', { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
+    } catch {
+      diff = '';
+    }
+  }
+
+  if (!diff) {
+    return { label, committedLines: 0, note: 'no commits to compare' };
+  }
+
+  const lines = diff.split('\n');
+  let addedLines = 0;
+  let removedLines = 0;
+
+  for (const line of lines) {
+    if (line.startsWith('+') && !line.startsWith('+++')) addedLines++;
+    if (line.startsWith('-') && !line.startsWith('---')) removedLines++;
+  }
+
+  const result = {
+    label,
+    timestamp: new Date().toISOString(),
+    committedAdded: addedLines,
+    committedRemoved: removedLines,
+  };
+
+  storeMetric(changeDir, 'commit_diff', result);
+  return result;
+}
+
+function computeAdoptionRate(changeDir) {
+  const snapshots = fs.readdirSync(resolveMetricsDir(changeDir))
+    .filter(f => f.startsWith('snapshot_'))
+    .sort();
+
+  const commits = fs.readdirSync(resolveMetricsDir(changeDir))
+    .filter(f => f.startsWith('commit_') || f.includes('commit_diff'))
+    .sort();
+
+  if (snapshots.length === 0) {
+    return { adoptionRate: null, note: 'no snapshots recorded. Run captureDraftSnapshot first.' };
+  }
+
+  const firstSnapshot = JSON.parse(
+    fs.readFileSync(path.join(resolveMetricsDir(changeDir), snapshots[0]), 'utf8')
+  );
+  const lastFile = snapshots[snapshots.length - 1];
+  const lastSnapshot = JSON.parse(
+    fs.readFileSync(path.join(resolveMetricsDir(changeDir), lastFile), 'utf8')
+  );
+
+  const result = {
+    firstDraft: firstSnapshot.addedLines,
+    finalDraft: lastSnapshot.addedLines,
+    netChange: lastSnapshot.addedLines - firstSnapshot.addedLines,
+    snapshots: snapshots.length,
+    note: 'adoption rate = committedLines / firstDraftLines. Requires commit data for full picture.',
+  };
+
+  storeMetric(changeDir, 'adoption_rate', result);
+  return result;
+}
+
+function storeMetric(changeDir, metricType, data) {
+  const all = loadAllMetrics(changeDir);
+  if (!all[metricType]) all[metricType] = [];
+  all[metricType].push(data);
+  fs.writeFileSync(metricsFile(changeDir), JSON.stringify(all, null, 2) + '\n');
+}
+
+function loadAllMetrics(changeDir) {
+  const fp = metricsFile(changeDir);
+  if (!fs.existsSync(fp)) return {};
+  return JSON.parse(fs.readFileSync(fp, 'utf8'));
+}
+
+function metricsReport(changeDir) {
+  const metrics = loadAllMetrics(changeDir);
+  const report = {};
+
+  for (const [type, entries] of Object.entries(metrics)) {
+    report[type] = {
+      count: entries.length,
+      latest: entries[entries.length - 1],
+    };
+  }
+
+  return report;
+}
+
+module.exports = {
+  captureDraftSnapshot,
+  captureCommitDiff,
+  computeAdoptionRate,
+  storeMetric,
+  loadAllMetrics,
+  metricsReport,
+};

package/src/evidence/canvas.js

@@ -0,0 +1,184 @@
+const fs = require('fs');
+const path = require('path');
+const { eventStats } = require('./sink-events');
+const { stageReport, formatDuration } = require('./stage-timing');
+const { metricsReport } = require('./ai-draft-metrics');
+
+function readPhaseState(changeDir) {
+  const fp = path.join(changeDir, '.phase-state.json');
+  if (!fs.existsSync(fp)) return null;
+  return JSON.parse(fs.readFileSync(fp, 'utf8'));
+}
+
+function readProgress(changeDir) {
+  const fp = path.join(changeDir, '.progress.json');
+  if (!fs.existsSync(fp)) return null;
+  return JSON.parse(fs.readFileSync(fp, 'utf8'));
+}
+
+function generateDashboard(changeDir, opts = {}) {
+  const phaseState = readPhaseState(changeDir);
+  const progress = readProgress(changeDir);
+  const events = eventStats(changeDir);
+  const timing = stageReport(changeDir);
+  const metrics = metricsReport(changeDir);
+
+  const change = phaseState ? phaseState.change : path.basename(changeDir);
+  const phase = phaseState ? phaseState.phase : 'unknown';
+  const mode = phaseState ? phaseState.mode : 'unknown';
+
+  const eventTypeRows = Object.entries(events.byType)
+    .map(([type, count]) => `<tr><td>${type}</td><td>${count}</td></tr>`)
+    .join('\n');
+
+  const stageRows = timing.stages.map(s => `
+    <tr>
+      <td>${s.stage}</td>
+      <td>${s.duration || 'N/A'}</td>
+      <td>${s.completedAt ? '✓' : '○'}</td>
+    </tr>
+  `).join('\n');
+
+  const gateResults = progress && progress.gateResults ? Object.entries(progress.gateResults)
+    .map(([gate, result]) => {
+      const icon = result === 'passed' ? '✓' : result === 'failed' ? '✗' : '○';
+      return `<span class="gate ${result}">${icon} ${gate}</span>`;
+    }).join(' ') : '<span class="gate">no gate data</span>';
+
+  const taskInfo = progress
+    ? `<span>已完成 ${progress.completedTasks?.length || 0} 项</span>`
+    : '<span>无任务数据</span>';
+
+  return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>ATD Canvas — ${change}</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0d1117; color: #c9d1d9; padding: 24px; }
+  .header { margin-bottom: 24px; }
+  .header h1 { font-size: 24px; color: #58a6ff; }
+  .header .meta { color: #8b949e; font-size: 14px; margin-top: 4px; }
+  .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(320px, 1fr)); gap: 16px; }
+  .card { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 16px; }
+  .card h2 { font-size: 14px; color: #8b949e; text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 12px; border-bottom: 1px solid #21262d; padding-bottom: 8px; }
+  .stat { display: flex; justify-content: space-between; align-items: center; padding: 4px 0; }
+  .stat .label { color: #8b949e; font-size: 13px; }
+  .stat .value { font-size: 18px; font-weight: 600; }
+  .stat .value.green { color: #3fb950; }
+  .stat .value.yellow { color: #d29922; }
+  .stat .value.red { color: #f85149; }
+  .stat .value.blue { color: #58a6ff; }
+  table { width: 100%; border-collapse: collapse; font-size: 13px; }
+  th, td { text-align: left; padding: 6px 4px; border-bottom: 1px solid #21262d; }
+  th { color: #8b949e; font-weight: 500; }
+  .timeline { font-size: 12px; }
+  .timeline .entry { padding: 3px 0; border-left: 2px solid #30363d; padding-left: 10px; margin-left: 4px; }
+  .timeline .entry .ts { color: #484f58; font-size: 11px; }
+  .gate { display: inline-block; padding: 2px 8px; border-radius: 12px; font-size: 12px; margin: 2px; }
+  .gate.passed { background: #1b3826; color: #3fb950; }
+  .gate.failed { background: #3d1f1f; color: #f85149; }
+  .gate.null { background: #21262d; color: #8b949e; }
+  .phase-badge { display: inline-block; padding: 4px 12px; border-radius: 12px; font-size: 14px; font-weight: 600; }
+  .phase-badge.open { background: #1b3826; color: #3fb950; }
+  .phase-badge.design { background: #1a2e3f; color: #58a6ff; }
+  .phase-badge.build { background: #3d2e00; color: #d29922; }
+  .phase-badge.verify { background: #2b1a3d; color: #bc8cff; }
+  .phase-badge.archive { background: #21262d; color: #8b949e; }
+  footer { margin-top: 24px; color: #484f58; font-size: 11px; text-align: center; }
+</style>
+</head>
+<body>
+<div class="header">
+  <h1>ATD Canvas</h1>
+  <div class="meta">
+    Change: <strong>${change}</strong> &middot;
+    Mode: ${mode} &middot;
+    Updated: ${phaseState?.updatedAt || 'N/A'}
+  </div>
+</div>
+
+<div class="grid">
+  <div class="card">
+    <h2>当前状态</h2>
+    <div class="stat">
+      <span class="label">阶段</span>
+      <span class="phase-badge ${phase}">${phase}</span>
+    </div>
+    <div class="stat">
+      <span class="label">事件总数</span>
+      <span class="value blue">${events.total}</span>
+    </div>
+    <div class="stat">
+      <span class="label">总耗时</span>
+      <span class="value">${timing.totalElapsed || 'N/A'}</span>
+    </div>
+  </div>
+
+  <div class="card">
+    <h2>质量门禁</h2>
+    ${gateResults}
+    <div style="margin-top: 8px;">${taskInfo}</div>
+  </div>
+
+  <div class="card">
+    <h2>阶段耗时</h2>
+    <table>
+      <tr><th>阶段</th><th>耗时</th><th>完成</th></tr>
+      ${stageRows || '<tr><td colspan="3">无阶段数据</td></tr>'}
+    </table>
+  </div>
+
+  <div class="card">
+    <h2>事件类型分布</h2>
+    <table>
+      <tr><th>类型</th><th>数量</th></tr>
+      ${eventTypeRows || '<tr><td colspan="2">无事件数据</td></tr>'}
+    </table>
+  </div>
+
+  <div class="card" style="grid-column: span 2;">
+    <h2>事件时间线</h2>
+    <div class="timeline">
+      ${events.timeline.slice(-20).map(e => `
+        <div class="entry">
+          <span class="ts">${e.timestamp?.slice(11, 19) || '--:--:--'}</span>
+          <strong>${e.type}</strong>
+          <span style="color: #8b949e">${e.phase ? ' · ' + e.phase : ''}</span>
+        </div>
+      `).join('\n')}
+    </div>
+  </div>
+
+  ${Object.keys(metrics).length > 0 ? `
+  <div class="card">
+    <h2>AI Draft Metrics</h2>
+    ${Object.entries(metrics).map(([type, info]) => `
+      <div class="stat">
+        <span class="label">${type}</span>
+        <span class="value blue">${info.count} entries</span>
+      </div>
+    `).join('\n')}
+  </div>
+  ` : ''}
+</div>
+
+<footer>
+  ATD Studio Evidence Canvas · Generated ${new Date().toISOString()}
+</footer>
+</body>
+</html>`;
+}
+
+function writeCanvas(changeDir, outPath) {
+  const html = generateDashboard(changeDir);
+  const dest = outPath || path.join(changeDir, '.evidence', 'canvas.html');
+  const dir = path.dirname(dest);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(dest, html);
+  return dest;
+}
+
+module.exports = { generateDashboard, writeCanvas };

package/src/evidence/index.js

@@ -0,0 +1,98 @@
+const { writeEvent, listEvents, eventStats, latestPhase, centralEvidenceRoot } = require('./sink-events');
+const { stageStart, stageComplete, getStageDuration, formatDuration, totalElapsed, stageReport } = require('./stage-timing');
+const { captureDraftSnapshot, captureCommitDiff, computeAdoptionRate, metricsReport } = require('./ai-draft-metrics');
+const { generateDashboard, writeCanvas } = require('./canvas');
+
+const path = require('path');
+
+function resolveChangeDir(changeName) {
+  return path.resolve(process.cwd(), 'openspec', 'changes', changeName);
+}
+
+function allEvidence(changeName) {
+  const dir = resolveChangeDir(changeName);
+  return {
+    events: eventStats(dir),
+    timing: stageReport(dir),
+    metrics: metricsReport(dir),
+  };
+}
+
+function recordPhaseTransition(changeName, from, to, opts = {}) {
+  const dir = resolveChangeDir(changeName);
+
+  stageComplete(dir, from, { reason: `transition to ${to}` });
+  stageStart(dir, to, { reason: `transition from ${from}` });
+
+  writeEvent(dir, 'phase_transition', { from, to }, {
+    change: changeName,
+    phase: to,
+    actorType: opts.actorType || 'agent',
+  });
+}
+
+function recordIntake(changeName, opts = {}) {
+  const dir = resolveChangeDir(changeName);
+  stageStart(dir, 'open', { reason: 'intake' });
+
+  writeEvent(dir, 'intake', {
+    mode: opts.mode || 'full',
+    risk_level: opts.riskLevel || 'low',
+  }, {
+    change: changeName,
+    phase: 'open',
+    actorType: opts.actorType || 'agent',
+  });
+}
+
+function recordGateCheck(changeName, gate, result, details = {}) {
+  const dir = resolveChangeDir(changeName);
+  writeEvent(dir, 'gate_check', { gate, result, ...details }, {
+    change: changeName,
+    phase: 'build',
+  });
+}
+
+function recordVerification(changeName, result, details = {}) {
+  const dir = resolveChangeDir(changeName);
+  writeEvent(dir, 'verification', { result, ...details }, {
+    change: changeName,
+    phase: 'verify',
+  });
+}
+
+function recordDone(changeName, details = {}) {
+  const dir = resolveChangeDir(changeName);
+  stageComplete(dir, 'verify', { reason: 'done' });
+
+  writeEvent(dir, 'done', details, {
+    change: changeName,
+    phase: 'archive',
+  });
+}
+
+module.exports = {
+  writeEvent,
+  listEvents,
+  eventStats,
+  latestPhase,
+  stageStart,
+  stageComplete,
+  getStageDuration,
+  formatDuration,
+  totalElapsed,
+  stageReport,
+  captureDraftSnapshot,
+  captureCommitDiff,
+  computeAdoptionRate,
+  metricsReport,
+  generateDashboard,
+  writeCanvas,
+  allEvidence,
+  resolveChangeDir,
+  recordPhaseTransition,
+  recordIntake,
+  recordGateCheck,
+  recordVerification,
+  recordDone,
+};

package/src/evidence/sink-events.js

@@ -0,0 +1,165 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+
+const SCHEMA_VERSION = 'atd.evidence.event.v1';
+
+const VALID_EVENT_TYPES = new Set([
+  'intake',
+  'phase_transition',
+  'spec_approve',
+  'plan_approve',
+  'task_start',
+  'task_complete',
+  'task_fail',
+  'gate_check',
+  'verification',
+  'done',
+  'guard_block',
+  'agent_action',
+  'risk_assessment',
+  'context_basis',
+  'review_gate',
+  'completion_gate',
+  'stage_timing',
+  'ai_draft_metric',
+]);
+
+function eventId() {
+  return crypto.randomUUID();
+}
+
+function timestamp() {
+  return new Date().toISOString();
+}
+
+function _repoName() {
+  try {
+    const { execSync } = require('child_process');
+    const remote = execSync('git remote get-url origin 2>/dev/null || echo ""', { encoding: 'utf8' }).trim();
+    if (remote) return remote.replace(/.*\//, '').replace(/\.git$/, '');
+    const toplevel = execSync('git rev-parse --show-toplevel 2>/dev/null || echo ""', { encoding: 'utf8' }).trim();
+    if (toplevel) return path.basename(toplevel);
+  } catch {}
+  return path.basename(process.cwd());
+}
+
+function centralEvidenceRoot() {
+  return path.join(os.homedir(), 'atdc', 'evidence', _repoName());
+}
+
+function resolveEvidenceDir(changeDir) {
+  const changeName = path.basename(changeDir);
+  const central = path.join(centralEvidenceRoot(), 'changes', changeName);
+  const eventsDir = path.join(central, 'events');
+  fs.mkdirSync(eventsDir, { recursive: true });
+
+  const localLink = path.join(changeDir, '.evidence');
+  if (!fs.existsSync(localLink)) {
+    try { fs.symlinkSync(central, localLink, 'dir'); } catch (e) { if (e.code !== 'EEXIST') throw e; }
+  } else if (!fs.lstatSync(localLink).isSymbolicLink()) {
+    // migrate existing real dir
+    try {
+      const { execSync } = require('child_process');
+      execSync(`cp -rn "${localLink}/" "${central}/" 2>/dev/null || true`);
+      fs.rmSync(localLink, { recursive: true, force: true });
+      fs.symlinkSync(central, localLink, 'dir');
+    } catch {}
+  }
+  return eventsDir;
+}
+
+function writeEvent(changeDir, eventType, payload = {}, opts = {}) {
+  if (!VALID_EVENT_TYPES.has(eventType)) {
+    throw new Error(`Invalid event type: ${eventType}. Valid: ${[...VALID_EVENT_TYPES].join(', ')}`);
+  }
+
+  const dir = resolveEvidenceDir(changeDir);
+  const ts = timestamp();
+  const id = eventId();
+  const safeType = eventType.replace(/[^a-z0-9_]/g, '_');
+
+  const event = {
+    schema: SCHEMA_VERSION,
+    event_id: id,
+    event_type: eventType,
+    timestamp: ts,
+    change: opts.change || path.basename(changeDir),
+    phase: opts.phase || 'unknown',
+    actor: {
+      type: opts.actorType || 'agent',
+      identity: opts.actorIdentity || (process.env.USER || 'unknown'),
+    },
+    payload,
+  };
+
+  const filename = `${ts.replace(/[:.]/g, '-')}_${safeType}_${id.slice(0, 8)}.json`;
+  const filepath = path.join(dir, filename);
+
+  fs.writeFileSync(filepath, JSON.stringify(event, null, 2) + '\n');
+  return { event, filepath };
+}
+
+function listEvents(changeDir, opts = {}) {
+  const dir = path.join(changeDir, '.evidence', 'events');
+  if (!fs.existsSync(dir)) return [];
+
+  let files = fs.readdirSync(dir)
+    .filter(f => f.endsWith('.json'))
+    .sort();
+
+  if (opts.type) {
+    files = files.filter(f => f.includes(opts.type));
+  }
+  if (opts.limit && opts.limit > 0) {
+    files = files.slice(-opts.limit);
+  }
+
+  return files.map(f => {
+    const data = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'));
+    return { file: f, event: data };
+  });
+}
+
+function eventStats(changeDir) {
+  const events = listEvents(changeDir);
+  const byType = {};
+  const timeline = [];
+
+  for (const { event } of events) {
+    const t = event.event_type;
+    byType[t] = (byType[t] || 0) + 1;
+    timeline.push({
+      type: t,
+      timestamp: event.timestamp,
+      phase: event.phase,
+    });
+  }
+
+  return {
+    total: events.length,
+    byType,
+    timeline,
+    firstEvent: timeline[0] || null,
+    lastEvent: timeline[timeline.length - 1] || null,
+  };
+}
+
+function latestPhase(changeDir) {
+  const events = listEvents(changeDir, { type: 'phase_transition' });
+  if (events.length === 0) return null;
+  return events[events.length - 1].event.payload.to || events[events.length - 1].event.payload.phase;
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  VALID_EVENT_TYPES,
+  eventId,
+  timestamp,
+  centralEvidenceRoot,
+  writeEvent,
+  listEvents,
+  eventStats,
+  latestPhase,
+};