@chongyan/autospec 1.0.1

package/scripts/install/skills.js

@@ -0,0 +1,95 @@
+/**
+ * Skills generator for Claude Code integration
+ *
+ * Generates skill files from templates directory with variable replacement.
+ * Source: plugins/skills/{skill-name}/SKILL.md
+ * Target: .claude/skills/{skill-name}/SKILL.md
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// ESM __dirname equivalent
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Role name mapping (for backward compatibility)
+const ROLE_ALIAS = {
+  'backend': 'backend-engineer',
+  'frontend': 'frontend-engineer',
+  'data': 'data-engineer',
+  'ai': 'ai-engineer',
+  'quality': 'quality-engineer'
+};
+
+/**
+ * Replace template variables in content
+ * @param {string} content - Template content
+ * @returns {string} - Content with variables replaced
+ */
+function replaceVariables(content) {
+  // Replace ${FW} with .autospec/knowledge (backward compat)
+  // Replace ${KNOWLEDGE} with .autospec/knowledge
+  return content
+    .replace(/\$\{FW\}/g, '.autospec/knowledge')
+    .replace(/\$\{KNOWLEDGE\}/g, '.autospec/knowledge');
+}
+
+/**
+ * Generate all skill files from templates
+ * @param {string} claudeDir - Target .claude directory path
+ */
+export function generateSkills(claudeDir) {
+  const skillsDir = path.join(claudeDir, 'skills');
+  fs.mkdirSync(skillsDir, { recursive: true });
+
+  // Get templates directory path (relative to this file)
+  // __dirname is scripts/install/, templates are in ../../plugins/skills/
+  const templatesDir = path.join(__dirname, '../../plugins/skills');
+
+  // Check if templates directory exists
+  if (!fs.existsSync(templatesDir)) {
+    console.warn('Warning: plugins/skills/ directory not found, skipping skill generation');
+    return;
+  }
+
+  // Get all skill directories
+  const skillDirs = fs.readdirSync(templatesDir).filter(f => {
+    const skillPath = path.join(templatesDir, f);
+    return fs.statSync(skillPath).isDirectory();
+  });
+
+  // Process each skill
+  for (const skillName of skillDirs) {
+    const skillFile = path.join(templatesDir, skillName, 'SKILL.md');
+    if (fs.existsSync(skillFile)) {
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const processed = replaceVariables(content);
+
+      const targetDir = path.join(skillsDir, skillName);
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(path.join(targetDir, 'SKILL.md'), processed, 'utf-8');
+    }
+  }
+}
+
+/**
+ * Get list of available skill names
+ * @returns {string[]} - Array of skill names
+ */
+export function getAvailableSkills() {
+  const templatesDir = path.join(__dirname, '../../plugins/skills');
+
+  if (!fs.existsSync(templatesDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(templatesDir).filter(f => {
+    const skillPath = path.join(templatesDir, f);
+    const skillFile = path.join(skillPath, 'SKILL.md');
+    return fs.statSync(skillPath).isDirectory() && fs.existsSync(skillFile);
+  });
+}
+
+export { ROLE_ALIAS };

package/scripts/postinstall.js

@@ -0,0 +1,25 @@
+/**
+ * AutoSpec postinstall script
+ * Shows quick start guide after npm install
+ */
+
+const isGlobal = process.env.npm_config_global === 'true';
+
+if (isGlobal) {
+  console.log(`
+┌─────────────────────────────────────────────┐
+│                                             │
+│   AutoSpec installed successfully!          │
+│                                             │
+│   Quick start:                              │
+│     cd your-project                         │
+│     autospec init                           │
+│                                             │
+│   Then in Claude Code:                      │
+│     /autospec:run    → Full pipeline        │
+│     /autospec:run --workflow=hotfix         │
+│     /autospec:run --workflow=experiment     │
+│                                             │
+└─────────────────────────────────────────────┘
+`);
+}

package/scripts/state.js

@@ -0,0 +1,376 @@
+/**
+ * Pipeline state management
+ * Tracks which stage the pipeline is at for a given task
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { STATE_FILE, METRICS_FILE, STAGES, WORKFLOWS, AUTOSPEC_DIRS } from './constants.js';
+
+const ARCHIVES_DIR = `.autospec/${AUTOSPEC_DIRS.ARCHIVES}`;
+
+/**
+ * Initialize or load pipeline state
+ */
+export function loadState(projectDir) {
+  const statePath = path.join(projectDir, STATE_FILE);
+  if (fs.existsSync(statePath)) {
+    return JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+  }
+  return null;
+}
+
+/**
+ * Save pipeline state
+ */
+export function saveState(projectDir, state) {
+  const statePath = path.join(projectDir, STATE_FILE);
+  const dir = path.dirname(statePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  state.updatedAt = new Date().toISOString();
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+}
+
+/**
+ * Check if there's an active (incomplete) pipeline
+ */
+export function hasActivePipeline(projectDir) {
+  const state = loadState(projectDir);
+  if (!state) return false;
+  return !state.completedAt;
+}
+
+/**
+ * Archive completed pipeline to archives/{spec-id}/
+ * Called when a pipeline completes or when starting a new one
+ */
+export function archivePipeline(projectDir, specId) {
+  const state = loadState(projectDir);
+  if (!state) return false;
+
+  // Determine specId from state if not provided
+  const runId = specId || state.specs || generateRunId(state.taskName, state.createdAt);
+
+  // Create archives directory
+  const archivesDir = path.join(projectDir, ARCHIVES_DIR);
+  const archiveDir = path.join(archivesDir, runId);
+  if (!fs.existsSync(archiveDir)) {
+    fs.mkdirSync(archiveDir, { recursive: true });
+  }
+
+  // Copy state.json to archive
+  const archivedStatePath = path.join(archiveDir, 'state.json');
+  fs.writeFileSync(archivedStatePath, JSON.stringify(state, null, 2), 'utf-8');
+
+  // Copy metrics.json to archive if exists
+  const metricsPath = path.join(projectDir, METRICS_FILE);
+  if (fs.existsSync(metricsPath)) {
+    const archivedMetricsPath = path.join(archiveDir, 'metrics.json');
+    fs.copyFileSync(metricsPath, archivedMetricsPath);
+  }
+
+  // Mark state as archived
+  state.archivedAt = new Date().toISOString();
+  state.archivedTo = runId;
+
+  return runId;
+}
+
+/**
+ * Generate run ID from task name and timestamp
+ */
+function generateRunId(taskName, createdAt) {
+  const timestamp = createdAt ? new Date(createdAt).toISOString().slice(0, 10) : new Date().toISOString().slice(0, 10);
+  const slug = (taskName || 'unknown')
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+    .slice(0, 30);
+  return `${timestamp}-${slug}`;
+}
+
+/**
+ * Get list of archived runs
+ */
+export function listArchivedRuns(projectDir) {
+  const archivesDir = path.join(projectDir, ARCHIVES_DIR);
+  if (!fs.existsSync(archivesDir)) return [];
+
+  return fs.readdirSync(archivesDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => {
+      const archiveDir = path.join(archivesDir, dirent.name);
+      const statePath = path.join(archiveDir, 'state.json');
+      let runInfo = { id: dirent.name };
+      if (fs.existsSync(statePath)) {
+        try {
+          const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+          runInfo.taskName = state.taskName;
+          runInfo.workflow = state.workflow;
+          runInfo.completedAt = state.completedAt;
+          runInfo.archivedAt = state.archivedAt;
+        } catch { /* ignore */ }
+      }
+      return runInfo;
+    })
+    .sort((a, b) => (b.archivedAt || '').localeCompare(a.archivedAt || ''));
+}
+
+/**
+ * Load archived run state
+ */
+export function loadArchivedRun(projectDir, runId) {
+  const archiveDir = path.join(projectDir, ARCHIVES_DIR, runId);
+  const statePath = path.join(archiveDir, 'state.json');
+  if (fs.existsSync(statePath)) {
+    return JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+  }
+  return null;
+}
+
+/**
+ * Standard subsystem types
+ */
+export const SUBSYSTEM_TYPES = {
+  BACKEND: 'backend',
+  FRONTEND: 'frontend',
+  MOBILE: 'mobile',
+  DATA: 'data',
+  AI: 'ai',
+  PIPELINE: 'pipeline'
+};
+
+/**
+ * Labels for subsystem types
+ */
+export const SUBSYSTEM_TYPE_LABELS = {
+  [SUBSYSTEM_TYPES.BACKEND]: '后端',
+  [SUBSYSTEM_TYPES.FRONTEND]: '前端',
+  [SUBSYSTEM_TYPES.MOBILE]: '移动端',
+  [SUBSYSTEM_TYPES.DATA]: '数据系统',
+  [SUBSYSTEM_TYPES.AI]: 'AI/模型',
+  [SUBSYSTEM_TYPES.PIPELINE]: '数据管道'
+};
+
+/**
+ * Validate and normalize subsystem names to ensure uniqueness
+ * @param {Array} subsystems - subsystems from config
+ * @returns {Array} normalized subsystems with unique names
+ */
+export function normalizeSubsystems(subsystems) {
+  if (!subsystems || subsystems.length === 0) return [];
+
+  const nameCount = {};
+  const seenNames = new Set();
+
+  return subsystems.map(sub => {
+    let name = sub.name;
+
+    // Handle duplicate names by adding parent directory suffix
+    if (seenNames.has(name)) {
+      const parentDir = sub.path.split('/').slice(-2)[0];
+      name = `${name}-${parentDir}`;
+    }
+
+    // Track name occurrences
+    nameCount[name] = (nameCount[name] || 0) + 1;
+    if (nameCount[name] > 1) {
+      name = `${name}-${nameCount[name]}`;
+    }
+
+    seenNames.add(name);
+
+    return {
+      name,
+      type: sub.type || 'unknown',
+      path: sub.path
+    };
+  });
+}
+
+/**
+ * Create new pipeline state for a task
+ * @param {string} taskName - task name
+ * @param {string} workflow - workflow type
+ * @param {Array} roles - involved roles
+ * @param {Array} subsystems - optional subsystems config
+ */
+export function createState(taskName, workflow = 'waterfall', roles = [], subsystems = []) {
+  const wf = WORKFLOWS[workflow];
+  if (!wf) throw new Error(`Unknown workflow: ${workflow}`);
+
+  // Normalize subsystem names to ensure uniqueness
+  const normalizedSubsystems = normalizeSubsystems(subsystems);
+
+  const stages = {};
+  for (const stageId of wf.stages) {
+    const stage = STAGES.find(s => s.id === stageId);
+    const stageDef = {
+      name: stage.name,
+      label: stage.label,
+      status: 'pending',       // pending | in_progress | layer1_pass | layer2_pass | completed | blocked | failed
+      layer1: null,            // null | pass | fail | blocked
+      layer2: null,            // null | pass | fail
+      retryCount: 0,
+      artifacts: [],
+      assumptions: [],
+      startedAt: null,
+      completedAt: null
+    };
+
+    // Add subsystems array for multi-system projects
+    if (normalizedSubsystems.length > 0) {
+      stageDef.subsystems = normalizedSubsystems.map(sub => ({
+        name: sub.name,
+        type: sub.type,
+        status: 'pending',
+        layer1: null,
+        layer2: null,
+        retryCount: 0,
+        startedAt: null,
+        completedAt: null
+      }));
+    }
+
+    stages[stageId] = stageDef;
+  }
+
+  return {
+    version: '0.1.0',
+    taskName,
+    workflow,
+    roles,
+    hasSubsystems: normalizedSubsystems.length > 0,
+    subsystemsConfig: normalizedSubsystems.map(s => ({ name: s.name, type: s.type, path: s.path })),
+    currentStage: wf.stages[0],
+    stages,
+    pendingConfirmations: [],
+    autoDecisions: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+}
+
+/**
+ * Get status of a specific subsystem in a stage
+ * @param {Object} state - pipeline state
+ * @param {string} stageId - stage ID (e.g., '03')
+ * @param {string} subsystemName - subsystem name
+ * @returns {Object|null} subsystem status or null
+ */
+export function getSubsystemStatus(state, stageId, subsystemName) {
+  if (!state?.stages?.[stageId]?.subsystems) return null;
+  return state.stages[stageId].subsystems.find(s => s.name === subsystemName) || null;
+}
+
+/**
+ * Update status of a specific subsystem
+ * @param {Object} state - pipeline state
+ * @param {string} stageId - stage ID
+ * @param {string} subsystemName - subsystem name
+ * @param {Object} updates - status updates
+ */
+export function updateSubsystemStatus(state, stageId, subsystemName, updates) {
+  if (!state?.stages?.[stageId]?.subsystems) return false;
+
+  const subsystem = state.stages[stageId].subsystems.find(s => s.name === subsystemName);
+  if (!subsystem) return false;
+
+  Object.assign(subsystem, updates);
+  return true;
+}
+
+/**
+ * Group subsystems by type for display
+ * @param {Array} subsystems - subsystem status array
+ * @returns {Object} grouped by type
+ */
+function groupSubsystemsByType(subsystems) {
+  const groups = {};
+  for (const sub of subsystems) {
+    const type = sub.type || 'unknown';
+    if (!groups[type]) groups[type] = [];
+    groups[type].push(sub);
+  }
+  return groups;
+}
+
+/**
+ * Get status icon for display
+ */
+function getStatusIcon(status) {
+  return {
+    pending: '○',
+    in_progress: '◎',
+    layer1_pass: '◐',
+    layer2_pass: '◑',
+    completed: '●',
+    blocked: '✖',
+    failed: '✖'
+  }[status] || '?';
+}
+
+/**
+ * Get human-readable status summary
+ * Supports both single-system and multi-system modes
+ */
+export function getStatusSummary(state) {
+  if (!state) return null;
+
+  const wf = WORKFLOWS[state.workflow];
+  const lines = [];
+  lines.push(`Task: ${state.taskName}`);
+  lines.push(`Workflow: ${wf.label} (${state.workflow})`);
+  lines.push(`Roles: ${state.roles.length > 0 ? state.roles.join(', ') : '(none)'}`);
+  lines.push(`Mode: ${state.hasSubsystems ? 'Multi-system' : 'Single-system'}`);
+  lines.push(`Current: Stage ${state.currentStage}`);
+  lines.push('');
+
+  // Show subsystems config if present
+  if (state.hasSubsystems && state.subsystemsConfig) {
+    lines.push('Subsystems:');
+    const groups = groupSubsystemsByType(state.subsystemsConfig);
+    for (const [type, subs] of Object.entries(groups)) {
+      const typeLabel = SUBSYSTEM_TYPE_LABELS[type] || type;
+      lines.push(`  [${typeLabel}] ${subs.map(s => s.name).join(', ')}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('Stages:');
+
+  for (const stageId of wf.stages) {
+    const s = state.stages[stageId];
+    const stage = STAGES.find(st => st.id === stageId);
+    const icon = getStatusIcon(s.status);
+    const current = stageId === state.currentStage ? ' ←' : '';
+    lines.push(`  ${icon} [${stageId}] ${stage.label} — ${s.status}${current}`);
+
+    // Show subsystem details for current stage in multi-system mode
+    if (s.subsystems && stageId === state.currentStage) {
+      const groups = groupSubsystemsByType(s.subsystems);
+      for (const [type, subs] of Object.entries(groups)) {
+        const typeLabel = SUBSYSTEM_TYPE_LABELS[type] || type;
+        lines.push(`      ${typeLabel}:`);
+        for (const sub of subs) {
+          const subIcon = getStatusIcon(sub.status);
+          const l1 = sub.layer1 ? `[L1:${sub.layer1}]` : '';
+          const l2 = sub.layer2 ? `[L2:${sub.layer2}]` : '';
+          lines.push(`        ${subIcon} ${sub.name} ${l1}${l2}`);
+        }
+      }
+    }
+  }
+
+  // Show pending items count if any
+  if (state.pendingConfirmations?.length > 0) {
+    lines.push('');
+    lines.push(`Pending confirmations: ${state.pendingConfirmations.length}`);
+  }
+  if (state.autoDecisions?.length > 0) {
+    lines.push(`Auto decisions: ${state.autoDecisions.length}`);
+  }
+
+  return lines.join('\n');
+}