@chongyan/autospec 1.0.2 → 1.0.4

package/scripts/install/skills.js

@@ -1,95 +0,0 @@
-/**
- * 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

@@ -1,25 +0,0 @@
-/**
- * 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

@@ -1,585 +0,0 @@
-/**
- * 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: '1.0.2',
-    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');
-}
-
-/**
- * Get all subsystems status for current stage
- * @param {Object} state - pipeline state
- * @returns {Array} all subsystems status for current stage
- */
-export function getAllSubsystemsStatus(state) {
-  if (!state?.stages?.[state.currentStage]?.subsystems) {
-    return [];
-  }
-  return state.stages[state.currentStage].subsystems;
-}
-
-/**
- * Get subsystem coverage report
- * Compares designed subsystems vs implemented subsystems
- * @param {string} projectDir - project directory
- * @param {Object} state - pipeline state
- * @returns {Object} coverage report
- */
-export function getSubsystemCoverage(state, designSubsystems = []) {
-  if (!state?.stages?.[state.currentStage]?.subsystems) {
-    return {
-      designed: [],
-      implemented: [],
-      coverage: 0,
-      missing: [],
-      completed: [],
-      inProgress: [],
-      pending: []
-    };
-  }
-
-  const currentSubsystems = state.stages[state.currentStage].subsystems;
-
-  // Categorize by status
-  const completed = currentSubsystems.filter(s => s.status === 'completed');
-  const inProgress = currentSubsystems.filter(s => s.status === 'in_progress' || s.status === 'layer1_pass');
-  const pending = currentSubsystems.filter(s => s.status === 'pending');
-
-  // Calculate coverage
-  const total = currentSubsystems.length;
-  const covered = completed.length + inProgress.length;
-  const coverageRate = total > 0 ? Math.round((covered / total) * 100) : 0;
-
-  return {
-    designed: currentSubsystems.map(s => ({ name: s.name, type: s.type, path: s.path })),
-    implemented: currentSubsystems.filter(s => s.status !== 'pending'),
-    coverage: coverageRate,
-    missing: pending.map(s => s.name),
-    completed: completed.map(s => s.name),
-    inProgress: inProgress.map(s => s.name),
-    pending: pending.map(s => s.name),
-    details: currentSubsystems
-  };
-}
-
-/**
- * Get monitoring issues from .autospec/monitoring-issues.json
- * @param {string} projectDir - project directory
- * @returns {Array} monitoring issues
- */
-export function getMonitoringIssues(projectDir) {
-  const monitoringIssuesPath = path.join(projectDir, '.autospec/monitoring-issues.json');
-  if (fs.existsSync(monitoringIssuesPath)) {
-    try {
-      return JSON.parse(fs.readFileSync(monitoringIssuesPath, 'utf-8'));
-    } catch {
-      return [];
-    }
-  }
-  return [];
-}
-
-/**
- * Add monitoring issue to .autospec/monitoring-issues.json
- * @param {string} projectDir - project directory
- * @param {Object} issue - issue to add
- */
-export function addMonitoringIssue(projectDir, issue) {
-  const monitoringIssuesPath = path.join(projectDir, '.autospec/monitoring-issues.json');
-
-  let issues = [];
-  if (fs.existsSync(monitoringIssuesPath)) {
-    try {
-      issues = JSON.parse(fs.readFileSync(monitoringIssuesPath, 'utf-8'));
-    } catch {
-      issues = [];
-    }
-  }
-
-  const newIssue = {
-    id: `issue-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    status: 'open', // open | acknowledged | fixing | fixed | closed
-    ...issue
-  };
-
-  issues.push(newIssue);
-
-  const dir = path.dirname(monitoringIssuesPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  fs.writeFileSync(monitoringIssuesPath, JSON.stringify(issues, null, 2), 'utf-8');
-  return newIssue;
-}
-
-/**
- * Update monitoring issue status
- * @param {string} projectDir - project directory
- * @param {string} issueId - issue ID
- * @param {Object} updates - status updates
- * @returns {boolean} success
- */
-export function updateMonitoringIssue(projectDir, issueId, updates) {
-  const monitoringIssuesPath = path.join(projectDir, '.autospec/monitoring-issues.json');
-
-  if (!fs.existsSync(monitoringIssuesPath)) {
-    return false;
-  }
-
-  let issues;
-  try {
-    issues = JSON.parse(fs.readFileSync(monitoringIssuesPath, 'utf-8'));
-  } catch {
-    return false;
-  }
-
-  const issueIndex = issues.findIndex(i => i.id === issueId);
-  if (issueIndex === -1) {
-    return false;
-  }
-
-  issues[issueIndex] = {
-    ...issues[issueIndex],
-    ...updates,
-    updatedAt: new Date().toISOString()
-  };
-
-  fs.writeFileSync(monitoringIssuesPath, JSON.stringify(issues, null, 2), 'utf-8');
-  return true;
-}
-
-/**
- * Get monitoring report summary
- * @param {string} projectDir - project directory
- * @returns {Object} monitoring report
- */
-export function getMonitoringReport(projectDir) {
-  const issues = getMonitoringIssues(projectDir);
-
-  const summary = {
-    total: issues.length,
-    open: issues.filter(i => i.status === 'open').length,
-    acknowledged: issues.filter(i => i.status === 'acknowledged').length,
-    fixing: issues.filter(i => i.status === 'fixing').length,
-    fixed: issues.filter(i => i.status === 'fixed').length,
-    closed: issues.filter(i => i.status === 'closed').length,
-    bySeverity: {
-      critical: issues.filter(i => i.severity === 'critical').length,
-      high: issues.filter(i => i.severity === 'high').length,
-      medium: issues.filter(i => i.severity === 'medium').length,
-      low: issues.filter(i => i.severity === 'low').length
-    },
-    recentIssues: issues.slice(-10).reverse()
-  };
-
-  return summary;
-}
-
-/**
- * Check if all subsystems have passed Layer 1 validation
- * @param {Object} state - pipeline state
- * @param {string} stageId - stage ID
- * @returns {Object} validation result
- */
-export function checkAllSubsystemsLayer1(state, stageId) {
-  const subsystems = state?.stages?.[stageId]?.subsystems;
-
-  if (!subsystems || subsystems.length === 0) {
-    return {
-      allPassed: true,
-      hasSubsystems: false,
-      details: []
-    };
-  }
-
-  const passed = subsystems.filter(s => s.layer1 === 'pass');
-  const failed = subsystems.filter(s => s.layer1 === 'fail');
-  const pending = subsystems.filter(s => !s.layer1 || s.layer1 === null);
-
-  return {
-    allPassed: failed.length === 0 && pending.length === 0,
-    hasSubsystems: true,
-    total: subsystems.length,
-    passed: passed.length,
-    failed: failed.length,
-    pending: pending.length,
-    details: subsystems.map(s => ({
-      name: s.name,
-      type: s.type,
-      layer1: s.layer1,
-      status: s.status
-    }))
-  };
-}