sillyspec 3.20.3 → 3.20.4

package/src/constants.js

@@ -0,0 +1,70 @@
+/**
+ * SillySpec 平台状态枚举
+ *
+ * 所有平台产物（manifest、pointer、postcheck、workflow-runs）共享这些枚举。
+ * SillyHub 侧直接使用常量值，不需要猜字符串。
+ */
+
+// ── scan 阶段状态 ──
+export const SCAN_STATUS = Object.freeze({
+  PENDING: 'pending',                        // scan 未开始
+  IN_PROGRESS: 'in_progress',                  // scan 进行中
+  SUCCESS: 'success',                          // scan 成功（所有检查通过）
+  COMPLETED_WITH_WARNINGS: 'completed_with_warnings',  // scan 成功但有警告
+  FAILED_POST_CHECK: 'failed_post_check',     // scan 失败（post-check 不通过）
+})
+
+// ── 平台指针状态 ──
+export const POINTER_STATUS = Object.freeze({
+  ACTIVE: 'active',                            // 指针活跃，任务进行中
+  SCAN_COMPLETED: 'scan_completed',             // scan 已完成
+  STALE: 'stale',                              // 指针过时（完成超过 24h，建议清理）
+  CORRUPTED: 'corrupted',                      // 指针损坏（缺少必要字段）
+})
+
+// ── workflow 检查状态 ──
+export const WORKFLOW_STATUS = Object.freeze({
+  PASS: 'pass',
+  FAIL: 'fail',
+  SKIPPED: 'skipped',
+})
+
+// ── postcheck 检查严重级别 ──
+export const CHECK_SEVERITY = Object.freeze({
+  FAILED: 'failed',
+  WARNING: 'warning',
+  PASSED: 'passed',
+})
+
+// ── stage 步骤状态 ──
+export const STEP_STATUS = Object.freeze({
+  PENDING: 'pending',
+  IN_PROGRESS: 'in-progress',
+  COMPLETED: 'completed',
+  SKIPPED: 'skipped',
+})
+
+// ── stage 阶段状态 ──
+export const STAGE_STATUS = Object.freeze({
+  PENDING: 'pending',
+  IN_PROGRESS: 'in_progress',
+  COMPLETED: 'completed',
+  FAILED_POST_CHECK: 'failed_post_check',
+})
+
+/**
+ * 判断指针是否过时（完成超过 24h）
+ */
+export function isPointerStale(pointer) {
+  if (!pointer.completedAt) return false
+  const completed = new Date(pointer.completedAt)
+  const age = Date.now() - completed.getTime()
+  return age > 24 * 60 * 60 * 1000
+}
+
+/**
+ * 判断指针是否损坏（缺少必要字段）
+ */
+export function isPointerCorrupted(pointer) {
+  return !pointer || !pointer.specRoot || !pointer.savedAt
+}

package/src/contract-matrix.js

@@ -0,0 +1,278 @@
+/**
+ * contract-matrix.js — API Contract Matrix 生成与注入
+ *
+ * plan 阶段：识别 task 之间的 provider/consumer 关系，生成契约矩阵
+ * execute 阶段：
+ *   - 后端 task 完成后自动提取 endpoint artifact
+ *   - 前端 task 开始时注入上游契约
+ * verify 阶段：读取 artifact 做 parity check
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs'
+import { join, resolve, basename, relative } from 'path'
+import {
+  scanBackendEndpoints,
+  scanFrontendApiCalls,
+  normalizePath,
+} from './endpoint-extractor.js'
+
+// ─── 关键词检测 ─────────────────────────────────────────────────────────
+
+const PROVIDER_KEYWORDS = /router|routes|endpoint|api|backend|controller|fastapi|flask|express|koa|spring/i
+const CONSUMER_KEYWORDS = /frontend|client|service|apiFetch|request|fetch|axios|http/i
+
+/**
+ * 判断一个 task 文档是 provider（产出 API）还是 consumer（消费 API）
+ * @param {string} taskContent - task markdown 内容
+ * @returns {{ isProvider: boolean, isConsumer: boolean, confidence: number }}
+ */
+export function classifyTask(taskContent) {
+  const isProvider = PROVIDER_KEYWORDS.test(taskContent)
+  const isConsumer = CONSUMER_KEYWORDS.test(taskContent)
+  // 避免所有 task 都被标记（因为几乎所有 task 都含 "api"）
+  // 加强判定：provider 要命中 router/endpoint/backend/controller + api
+  // consumer 要命中 frontend/client/apiFetch + api
+  const providerStrong = /router|endpoint|backend|controller|fastapi|flask/i.test(taskContent)
+  const consumerStrong = /frontend|apiFetch|axios|api.*client/i.test(taskContent)
+  const providerConfidence = providerStrong ? 0.8 : (isProvider ? 0.4 : 0)
+  const consumerConfidence = consumerStrong ? 0.8 : (isConsumer ? 0.4 : 0)
+  return {
+    isProvider: providerConfidence >= 0.4,
+    isConsumer: consumerConfidence >= 0.4,
+    confidence: Math.max(providerConfidence, consumerConfidence),
+  }
+}
+
+/**
+ * 从 plan.md 解析 task 依赖关系，识别 provider → consumer 对
+ * @param {string} planContent - plan.md 内容
+ * @param {string} changeDir - changes/<name>/ 目录
+ * @returns {Array<{ provider: string, consumer: string, type: string }>}
+ */
+export function buildContractMatrix(planContent, changeDir) {
+  const contracts = []
+
+  // 解析 task 依赖关系
+  // 格式: - [ ] task-04: ... (depends_on: [task-01]) 或
+  //        | task-04 | ... | 01 |
+  const taskDeps = parseTaskDependencies(planContent)
+
+  // 读取各 task 文档，分类 provider/consumer
+  const taskClasses = {}
+  for (const taskName of Object.keys(taskDeps)) {
+    const taskFile = join(changeDir, 'tasks', `${taskName}.md`)
+    if (existsSync(taskFile)) {
+      taskClasses[taskName] = classifyTask(readFileSync(taskFile, 'utf8'))
+    }
+  }
+
+  // 识别契约对：A depends_on B，且 A 是 consumer，B 是 provider
+  for (const [consumer, deps] of Object.entries(taskDeps)) {
+    const consumerClass = taskClasses[consumer]
+    if (!consumerClass?.isConsumer) continue
+
+    for (const provider of deps) {
+      const providerClass = taskClasses[provider]
+      if (!providerClass?.isProvider) continue
+
+      // 避免自引用和重复
+      if (consumer === provider) continue
+      const alreadyExists = contracts.some(
+        c => c.provider === provider && c.consumer === consumer
+      )
+      if (alreadyExists) continue
+
+      contracts.push({
+        provider,
+        consumer,
+        type: 'api',
+      })
+    }
+  }
+
+  return contracts
+}
+
+/**
+ * 从 plan.md 解析 task 依赖关系
+ * @param {string} planContent
+ * @returns {Record<string, string[]>} task → depends_on list
+ */
+function parseTaskDependencies(planContent) {
+  const deps = {}
+
+  // 方式 1: 表格形式 | task-04 | ... | 01,02 |
+  const tableRows = planContent.matchAll(/\|[^|]*task-(\d+)[^|]*\|[^|]*\|[^|]*(?:task-)?(\d+(?:\s*[,，]\s*\d+)*)[^|]*\|/gi)
+  for (const match of tableRows) {
+    const task = `task-${match[1]}`
+    const depList = match[2].split(/[,，\s]+/).map(d => `task-${d.trim()}`).filter(d => d.startsWith('task-'))
+    deps[task] = depList
+  }
+
+  // 方式 2: depends_on 关键字
+  const dependsPattern = planContent.matchAll(/task-(\d+).*?depends_on.*?(\d+(?:\s*[,，]\s*\d+)*)/gi)
+  for (const match of dependsPattern) {
+    const task = `task-${match[1]}`
+    const depList = match[2].split(/[,，\s]+/).map(d => `task-${d.trim()}`).filter(d => d.startsWith('task-'))
+    if (!deps[task]) deps[task] = []
+    for (const d of depList) {
+      if (!deps[task].includes(d)) deps[task].push(d)
+    }
+  }
+
+  return deps
+}
+
+// ─── Execute 阶段：后端 task 完成后提取 artifact ───────────────────────
+
+/**
+ * 后端 task 完成后，扫描变更文件提取 endpoint artifact
+ * @param {string} changeDir - changes/<name>/ 目录
+ * @param {string} worktreePath - worktree 路径（扫描源码用）
+ * @param {string} specBase - .sillyspec 目录
+ * @param {string} taskName - task-04
+ * @returns {{ ok: boolean, endpoints: Array, artifactPath: string|null }}
+ */
+export function extractProviderArtifact(changeDir, worktreePath, specBase, taskName) {
+  const artifactDir = join(specBase, '.runtime', 'contract-artifacts', taskName)
+  const artifactPath = join(artifactDir, 'endpoints.json')
+
+  if (!worktreePath || !existsSync(worktreePath)) {
+    return { ok: false, endpoints: [], artifactPath: null, error: 'worktree not found' }
+  }
+
+  try {
+    const endpoints = scanBackendEndpoints(worktreePath)
+
+    if (endpoints.length > 0) {
+      mkdirSync(artifactDir, { recursive: true })
+      const artifact = {
+        task: taskName,
+        type: 'backend_endpoints',
+        extractedAt: new Date().toISOString(),
+        endpoints: endpoints.map(e => ({
+          method: e.method,
+          path: normalizePath(e.path),
+          source: relative(worktreePath, e.source),
+          line: e.line,
+        })),
+      }
+      writeFileSync(artifactPath, JSON.stringify(artifact, null, 2) + '\n')
+      return { ok: true, endpoints: artifact.endpoints, artifactPath }
+    }
+
+    // 无端点提取到 — 不算错误（可能不是 router task）
+    return { ok: true, endpoints: [], artifactPath: null }
+  } catch (e) {
+    return { ok: false, endpoints: [], artifactPath: null, error: e.message }
+  }
+}
+
+// ─── Execute 阶段：前端 task 开始时注入契约 ─────────────────────────────
+
+/**
+ * 为 consumer task 构建上游契约注入文本
+ * @param {string} changeDir - changes/<name>/ 目录
+ * @param {string} specBase - .sillyspec 目录
+ * @param {string} taskName - 当前 task（consumer）
+ * @param {Array<{ provider: string, consumer: string, type: string }>} contracts
+ * @returns {string|null} 注入到 prompt 的契约文本，无契约时返回 null
+ */
+export function buildConsumerInjection(changeDir, specBase, taskName, contracts) {
+  const myContracts = contracts.filter(c => c.consumer === taskName)
+  if (myContracts.length === 0) return null
+
+  const parts = []
+  for (const contract of myContracts) {
+    const artifactDir = join(specBase, '.runtime', 'contract-artifacts', contract.provider)
+    const artifactFile = join(artifactDir, 'endpoints.json')
+
+    let endpoints = []
+    if (existsSync(artifactFile)) {
+      try {
+        const artifact = JSON.parse(readFileSync(artifactFile, 'utf8'))
+        endpoints = artifact.endpoints || []
+      } catch {}
+    }
+
+    parts.push(`### Upstream Contract: ${contract.provider}`)
+    if (endpoints.length > 0) {
+      parts.push(`\nAvailable endpoints from **${contract.provider}**:`)
+      for (const ep of endpoints) {
+        parts.push(`- **${ep.method}** \`${ep.path}\``)
+      }
+    } else {
+      parts.push(`\n⚠️ No endpoint artifact found for ${contract.provider}. This may indicate a contract gap.`)
+    }
+  }
+
+  if (parts.length === 0) return null
+
+  parts.unshift('## Upstream API Contracts')
+  parts.push('')
+  parts.push('### Rules')
+  parts.push('1. Do not invent API paths. Use only endpoints listed above.')
+  parts.push('2. If a required endpoint is missing, **stop and report the contract gap** instead of coding around it.')
+  parts.push('3. If you need to add new endpoints, you must also update the backend provider task.')
+
+  return parts.join('\n')
+}
+
+// ─── Verify 阶段：parity check ──────────────────────────────────────────
+
+/**
+ * verify 阶段执行 API parity check
+ * @param {string} specBase - .sillyspec 目录
+ * @param {string} worktreePath - worktree 路径
+ * @returns {{ ok: boolean, missingBackend: Array, unusedBackend: Array, summary: string }}
+ */
+export function verifyApiParity(specBase, worktreePath) {
+  const { diffApiParity } = require('./endpoint-extractor.js')
+
+  // 读取所有 provider artifacts
+  const artifactBase = join(specBase, '.runtime', 'contract-artifacts')
+  const allProviderEndpoints = []
+
+  if (existsSync(artifactBase)) {
+    for (const entry of readdirSync(artifactBase, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue
+      const epFile = join(artifactBase, entry.name, 'endpoints.json')
+      if (existsSync(epFile)) {
+        try {
+          const artifact = JSON.parse(readFileSync(epFile, 'utf8'))
+          for (const ep of (artifact.endpoints || [])) {
+            allProviderEndpoints.push({
+              method: ep.method,
+              path: ep.path,
+              source: `${entry.name}/${ep.source}`,
+            })
+          }
+        } catch {}
+      }
+    }
+  }
+
+  // 扫描前端调用
+  if (!worktreePath || !existsSync(worktreePath)) {
+    return {
+      ok: true,
+      missingBackend: [],
+      unusedBackend: [],
+      summary: 'No worktree to scan for parity check',
+    }
+  }
+
+  const frontendCalls = scanFrontendApiCalls(worktreePath)
+  const { missingBackend, unusedBackend } = diffApiParity(frontendCalls, allProviderEndpoints)
+
+  const ok = missingBackend.length === 0
+  let summary = ok
+    ? `✅ API parity check passed: ${allProviderEndpoints.length} backend endpoints, ${frontendCalls.length} frontend calls`
+    : `❌ API parity check failed: ${missingBackend.length} frontend calls have no matching backend endpoint`
+
+  if (unusedBackend.length > 0) {
+    summary += ` | ${unusedBackend.length} backend endpoints unused by frontend`
+  }
+
+  return { ok, missingBackend, unusedBackend, summary }
+}

package/src/db.js

@@ -0,0 +1,201 @@
+import initSqlJs from 'sql.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+
+export class DB {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = null;
+  }
+
+  async init() {
+    // 1. 确保父目录存在
+    const dir = dirname(this.dbPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+    // 2. 初始化 sql.js
+    const SQL = await initSqlJs();
+
+    // 3. 加载已有数据库或创建新库
+    if (existsSync(this.dbPath)) {
+      const buf = readFileSync(this.dbPath);
+      this.db = new SQL.Database(buf);
+    } else {
+      this.db = new SQL.Database();
+    }
+
+    // 4. 设置 PRAGMA
+    this.db.run('PRAGMA journal_mode = WAL');
+    this.db.run('PRAGMA busy_timeout = 5000');
+    this.db.run('PRAGMA foreign_keys = ON');
+    this.db.run('PRAGMA synchronous = NORMAL');
+
+    // 5. 创建表结构
+    this._createSchema();
+
+    // 6. 保存到磁盘
+    this._save();
+  }
+
+  close() {
+    if (this.db) {
+      this._save();
+      this.db.close();
+      this.db = null;
+    }
+  }
+
+  transaction(fn) {
+    if (!this.db) throw new Error('DB not initialized');
+    this.db.run('BEGIN');
+    try {
+      const result = fn(this.db);
+      this.db.run('COMMIT');
+      this._save();
+      return result;
+    } catch (err) {
+      this.db.run('ROLLBACK');
+      throw err;
+    }
+  }
+
+  /** 获取底层 db 对象（供 progress.js 直接使用） */
+  getDb() {
+    return this.db;
+  }
+
+  /** 将内存中的数据库持久化到磁盘 */
+  _save() {
+    if (!this.db) return;
+    const data = this.db.export();
+    const buffer = Buffer.from(data);
+    writeFileSync(this.dbPath, buffer);
+    // sql.js 的 export() 会重置 PRAGMA 状态，需要重新设置
+    this.db.run('PRAGMA journal_mode = WAL');
+    this.db.run('PRAGMA busy_timeout = 5000');
+    this.db.run('PRAGMA foreign_keys = ON');
+    this.db.run('PRAGMA synchronous = NORMAL');
+  }
+
+  _createSchema() {
+    // project 表
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS project (
+        id INTEGER PRIMARY KEY DEFAULT 1,
+        name TEXT NOT NULL,
+        schema_version INTEGER DEFAULT 4,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+
+    // changes 表
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS changes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        current_stage TEXT DEFAULT 'scan',
+        status TEXT DEFAULT 'active',
+        no_worktree INTEGER DEFAULT 0,
+        created_at TEXT NOT NULL,
+        last_active TEXT NOT NULL,
+        platform_change_id INTEGER,
+        platform_workspace_id INTEGER,
+        platform_last_sync TEXT,
+        platform_sync_enabled INTEGER DEFAULT 0
+      )
+    `);
+
+    // stages 表
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS stages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        change_id INTEGER NOT NULL REFERENCES changes(id) ON DELETE CASCADE,
+        stage TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        started_at TEXT,
+        completed_at TEXT,
+        UNIQUE(change_id, stage)
+      )
+    `);
+
+    // steps 表
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS steps (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        stage_id INTEGER NOT NULL REFERENCES stages(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        output TEXT,
+        completed_at TEXT,
+        ordering INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+
+    // batch_progress 表
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS batch_progress (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        change_id INTEGER NOT NULL REFERENCES changes(id) ON DELETE CASCADE,
+        total INTEGER DEFAULT 0,
+        completed INTEGER DEFAULT 0,
+        failed INTEGER DEFAULT 0,
+        skipped INTEGER DEFAULT 0,
+        UNIQUE(change_id)
+      )
+    `);
+
+    // approvals 表
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS approvals (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        change_id INTEGER NOT NULL REFERENCES changes(id) ON DELETE CASCADE,
+        status TEXT DEFAULT 'not_required',
+        requested_at TEXT,
+        approved_by TEXT,
+        approved_at TEXT,
+        rejection_reason TEXT,
+        UNIQUE(change_id)
+      )
+    `);
+
+    // 索引
+    this.db.run('CREATE INDEX IF NOT EXISTS idx_changes_current_stage ON changes(current_stage)');
+    this.db.run('CREATE INDEX IF NOT EXISTS idx_changes_status ON changes(status)');
+    this.db.run('CREATE INDEX IF NOT EXISTS idx_stages_change ON stages(change_id)');
+    this.db.run('CREATE INDEX IF NOT EXISTS idx_steps_stage ON steps(stage_id)');
+
+    // Migration: add isolation columns to changes table (idempotent)
+    this._migrateAddColumn('changes', 'isolation_status', 'TEXT');
+    this._migrateAddColumn('changes', 'isolation_mode', 'TEXT');
+    this._migrateAddColumn('changes', 'isolation_reason', 'TEXT');
+
+    // Migration: add waiting support columns to steps table (idempotent)
+    this._migrateAddColumn('steps', 'wait_reason', 'TEXT');
+    this._migrateAddColumn('steps', 'wait_options', 'TEXT');
+    this._migrateAddColumn('steps', 'wait_answer', 'TEXT');
+    this._migrateAddColumn('steps', 'waited_at', 'TEXT');
+    // repeatableWait support
+    this._migrateAddColumn('steps', 'wait_answers', 'TEXT'); // JSON array
+    this._migrateAddColumn('steps', 'wait_round', 'INTEGER');
+    this._migrateAddColumn('steps', 'max_wait_rounds', 'INTEGER');
+
+    // Revision v1 support
+    this._migrateAddColumn('stages', 'revision', 'INTEGER DEFAULT 0');
+    this._migrateAddColumn('stages', 'reopened_from_step', 'TEXT');
+    this._migrateAddColumn('stages', 'reopened_at', 'TEXT');
+    this._migrateAddColumn('stages', 'stale_reason', 'TEXT');
+  }
+
+  /**
+   * 幂等地给表添加列（列已存在则跳过）
+   * @private
+   */
+  _migrateAddColumn(table, column, type) {
+    try {
+      this.db.run(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+    } catch {
+      // 列已存在，静默跳过
+    }
+  }
+}