@hongmaple0820/scale-engine 0.12.2 → 0.13.0

package/dist/api/cli.js

@@ -12,6 +12,11 @@ import { DangerousCommandDetector, SecretLeakDetector, RoleGateDetector, ScopeCr
 import { SQLiteKnowledgeBase } from '../knowledge/SQLiteKnowledgeBase.js';
 import { ContextBuilder } from '../context/ContextBuilder.js';
 import { FSMAgentBridge } from '../fsm/FSMAgentBridge.js';
+import { CapabilityRegistry } from '../capabilities/CapabilityRegistry.js';
+import { SkillRegistry } from '../skills/SkillRegistry.js';
+import { registerCoreSkills } from '../skills/coreSkills.js';
+import { registerExternalSkills } from '../skills/ExternalSkills.js';
+import { createSkillPlan, evaluateSkillGate, loadSkillRoutingPolicy, skillPlanMarkdown } from '../skills/routing/index.js';
 import { createAdapter, SUPPORTED_AGENTS } from '../adapters/index.js';
 import { LessonExtractor, RuleProposer, HookGenerator, EvolutionEngine } from '../evolution/EvolutionEngine.js';
 import { Doctor } from './doctor.js';
@@ -21,17 +26,34 @@ import { listWorkflowPresets, getPresetsByScenario } from '../workflows/presets.
 import { EvidenceStore } from '../workflow/EvidenceStore.js';
 import { OutOfScopeStore } from '../workflow/OutOfScopeStore.js';
 import { ReviewStore } from '../workflow/ReviewStore.js';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { WorkflowEngine } from '../workflow/WorkflowEngine.js';
+import { resolveVerificationTargets } from '../workflow/VerificationProfile.js';
+import { writeGovernanceTemplates } from '../workflow/GovernanceTemplates.js';
+import { TaskMetricsStore } from '../workflow/TaskMetricsStore.js';
+import { checkTaskArtifactCompleteness } from '../workflow/TaskArtifactScaffolder.js';
+import { WorkflowArtifactWriter } from '../workflow/WorkflowArtifactWriter.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 // ============================================================================
 // Engine bootstrap (单例 + lazy init)
 // ============================================================================
 const SCALE_DIR = process.env.SCALE_DIR ?? '.scale';
+const PROJECT_DIR = process.env.SCALE_PROJECT_DIR ?? process.cwd();
 const DB_PATH = join(SCALE_DIR, 'scale.db');
+function governanceModeFromScenario(scenario) {
+    if (scenario === 'critical')
+        return 'critical';
+    if (scenario === 'sandbox')
+        return 'minimal';
+    return 'standard';
+}
 function ensureDir(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
 }
+function isTruthyFlag(value) {
+    return value === true || value === '' || value === 'true' || value === '1';
+}
 let _engine = null;
 function getEngine() {
     if (!_engine)
@@ -60,7 +82,17 @@ function createEngine() {
     const kb = new SQLiteKnowledgeBase(eventBus, { dbPath: join(SCALE_DIR, 'knowledge.db') });
     const ctx = new ContextBuilder(store, kb, eventBus);
     const fsmAgentBridge = new FSMAgentBridge(fsm, store);
-    return { eventBus, store, fsm, gateway, roleGate, kb, ctx, fsmAgentBridge };
+    const capabilityRegistry = new CapabilityRegistry(eventBus);
+    const skillRegistry = new SkillRegistry(eventBus);
+    registerCoreSkills(skillRegistry);
+    registerExternalSkills(skillRegistry, eventBus);
+    const workflowEngine = new WorkflowEngine({
+        eventBus,
+        capabilityRegistry,
+        skillRegistry,
+        scaleDir: SCALE_DIR,
+    });
+    return { eventBus, store, fsm, gateway, roleGate, kb, ctx, fsmAgentBridge, workflowEngine };
 }
 // ============================================================================
 // session commands
@@ -699,6 +731,161 @@ const stats = defineCommand({
         console.log(JSON.stringify({ ...s, eventCount: events.length }, null, 2));
     },
 });
+const metricsList = defineCommand({
+    meta: { name: 'list', description: 'List M/L task workflow metrics' },
+    args: {
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const store = new TaskMetricsStore(SCALE_DIR);
+        const records = store.list();
+        const summary = store.summarize();
+        if (args.json) {
+            console.log(JSON.stringify({ summary, records }, null, 2));
+            return;
+        }
+        console.log('\nWorkflow Metrics');
+        console.log(`  Total tasks: ${summary.total}`);
+        console.log(`  First-pass verification rate: ${(summary.firstPassRate * 100).toFixed(1)}%`);
+        console.log(`  Average fix iterations: ${summary.averageFixIterations.toFixed(2)}`);
+        console.log(`  Artifact completeness: ${(summary.artifactCompletenessRate * 100).toFixed(1)}%`);
+        for (const record of records.slice(-10)) {
+            console.log(`  - ${record.date} ${record.level} ${record.taskName}: ${record.finalGateStatus}`);
+        }
+    },
+});
+const metrics = defineCommand({
+    meta: { name: 'metrics', description: 'Inspect workflow task metrics' },
+    subCommands: { list: metricsList },
+});
+function normalizeTaskArtifactLevel(value) {
+    const normalized = String(value ?? 'M').trim().toUpperCase();
+    if (normalized === 'S' || normalized === 'M' || normalized === 'L' || normalized === 'CRITICAL') {
+        return normalized;
+    }
+    throw new Error(`Invalid task level "${String(value)}"; expected S, M, L, or CRITICAL.`);
+}
+const taskArtifactsCheck = defineCommand({
+    meta: { name: 'check', description: 'Check task artifact completeness' },
+    args: {
+        dir: { type: 'string', description: 'Task artifact directory; defaults to .scale/state/current.json artifactsDir' },
+        level: { type: 'string', description: 'Task level: S, M, L, or CRITICAL; defaults to current state level or M' },
+        'warn-only': { type: 'boolean', default: false, description: 'Return zero even when artifacts are incomplete' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const state = new WorkflowArtifactWriter(SCALE_DIR).readCurrentState();
+        let level;
+        try {
+            level = normalizeTaskArtifactLevel(args.level ?? state?.level ?? 'M');
+        }
+        catch (e) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        const result = checkTaskArtifactCompleteness({
+            projectDir: PROJECT_DIR,
+            artifactsDir: args.dir ?? state?.artifactsDir,
+            level,
+            skillRequiredArtifacts: state?.requiredSkillArtifacts,
+        });
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`\nTask Artifacts: ${result.complete ? 'COMPLETE' : 'INCOMPLETE'}`);
+            if (result.artifactsDir)
+                console.log(`  Directory: ${result.artifactsDir}`);
+            console.log(`  Required: ${result.required.join(', ') || 'none'}`);
+            for (const file of result.missing)
+                console.log(`  [MISSING] ${file}`);
+            for (const item of result.incomplete)
+                console.log(`  [INCOMPLETE] ${item.file}: ${item.reason}`);
+        }
+        if (!result.complete && !args['warn-only'])
+            process.exitCode = 1;
+    },
+});
+const taskArtifacts = defineCommand({
+    meta: { name: 'task-artifacts', description: 'Inspect task artifact completeness' },
+    subCommands: { check: taskArtifactsCheck },
+});
+const preflight = defineCommand({
+    meta: { name: 'preflight', description: 'Run service-aware verification without a task artifact' },
+    args: {
+        'build-cmd': { type: 'string', description: 'Override build command' },
+        'lint-cmd': { type: 'string', description: 'Override lint command' },
+        'test-cmd': { type: 'string', description: 'Override test command' },
+        'coverage-cmd': { type: 'string', description: 'Override coverage command' },
+        profile: { type: 'string', description: 'Verification profile from .scale/verification.json' },
+        service: { type: 'string', description: 'Service name from .scale/verification.json; use all for required services' },
+        'tdd-evidence': { type: 'string', description: 'Path to JSON TDD evidence with red/green/refactor/testFirst=true' },
+        'tdd-strict': { type: 'boolean', default: false, description: 'Require TDD evidence before other gates' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const { workflowEngine } = getEngine();
+        const resolved = resolveVerificationTargets({
+            projectDir: PROJECT_DIR,
+            scaleDir: SCALE_DIR,
+            profile: args.profile,
+            service: args.service,
+        });
+        const targetResults = [];
+        if (!args.json) {
+            console.log('\nSCALE Preflight');
+            for (const warning of resolved.warnings)
+                console.log(`  [WARN] ${warning}`);
+            console.log(`  Profile: ${resolved.profileName}`);
+        }
+        for (const target of resolved.targets) {
+            if (!args.json) {
+                const label = target.service ? `${target.service.name} (${target.service.path})` : 'root';
+                console.log(`\n  Target: ${label}`);
+            }
+            const gates = await workflowEngine.verify({
+                cwd: target.config.cwd,
+                build: args['build-cmd'] ?? target.config.build,
+                lint: args['lint-cmd'] ?? target.config.lint,
+                test: args['test-cmd'] ?? target.config.test,
+                coverage: args['coverage-cmd'] ?? target.config.coverage,
+                tddEvidence: args['tdd-evidence'],
+                tddStrict: isTruthyFlag(args['tdd-strict']),
+            });
+            const passed = gates.every(gate => gate.passed);
+            targetResults.push({
+                service: target.service?.name,
+                cwd: target.config.cwd ?? PROJECT_DIR,
+                gates,
+                passed,
+            });
+            if (!args.json) {
+                for (const gate of gates) {
+                    console.log(`    ${gate.passed ? '[PASS]' : '[FAIL]'} ${gate.gate}: ${gate.evidence.slice(0, 80)}`);
+                    for (const blocker of gate.blockers)
+                        console.log(`      [BLOCKER] ${blocker.slice(0, 120)}`);
+                }
+            }
+        }
+        const passed = targetResults.length > 0 && targetResults.every(target => target.passed);
+        const result = {
+            phase: 'PREFLIGHT',
+            profile: resolved.profileName,
+            services: targetResults.map(target => target.service).filter(Boolean),
+            policy: resolved.policy,
+            targets: targetResults,
+            passed,
+        };
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`\nPREFLIGHT: ${passed ? 'PASSED' : 'FAILED'}\n`);
+        }
+        if (!passed)
+            process.exitCode = 1;
+    },
+});
 const status = defineCommand({
     meta: { name: 'status', description: 'Show current SCALE workflow status' },
     args: {
@@ -821,8 +1008,88 @@ const init = defineCommand({
         dir: { type: 'string', default: '.', description: 'Project directory' },
         scenario: { type: 'string', default: 'standard', description: 'Scenario mode (sandbox/standard/critical)' },
         quick: { type: 'boolean', default: false, description: 'Quick start with auto-detection' },
+        interactive: { type: 'boolean', default: false, description: 'Interactive configuration mode with prompts' },
+        'coverage-threshold': { type: 'string', default: '80', description: 'Coverage threshold (default 80%)' },
+        'retry-threshold': { type: 'string', default: '3', description: 'Brute retry threshold (default 3)' },
+        'block-severity': { type: 'string', default: 'CRITICAL', description: 'Block severity level (CRITICAL/HIGH/MEDIUM)' },
     },
     async run({ args }) {
+        // Interactive configuration mode
+        if (args.interactive) {
+            console.log('\n🔧 SCALE Engine Interactive Configuration\n');
+            console.log('='.repeat(50));
+            // Step 1: Detect and suggest agent platform
+            const detection = detectPlatform(args.dir);
+            console.log('\n📋 Step 1: Agent Platform Selection');
+            console.log(`   Detected suggestions: ${detection.suggestions.join(', ') || 'none'}`);
+            const agentType = args.agent || detection.suggestions[0] || 'claude-code';
+            console.log(`   Using: ${agentType}`);
+            // Step 2: Scenario mode
+            console.log('\n📋 Step 2: Scenario Mode');
+            console.log('   sandbox    - No quality gates (POC/prototype)');
+            console.log('   standard   - Default quality gates');
+            console.log('   critical   - Hardened gates + manual approval');
+            const scenarioMode = args.scenario;
+            console.log(`   Using: ${scenarioMode}`);
+            // Step 3: Quality Gate Thresholds (quantified)
+            console.log('\n📋 Step 3: Quality Gate Thresholds');
+            const coverageThreshold = parseInt(args['coverage-threshold'], 10) || 80;
+            const retryThreshold = parseInt(args['retry-threshold'], 10) || 3;
+            const blockSeverity = args['block-severity'] || 'CRITICAL';
+            console.log(`   Coverage threshold:   ${coverageThreshold}%`);
+            console.log(`   Retry threshold:      ${retryThreshold} (brute retry block)`);
+            console.log(`   Block severity:       ${blockSeverity}`);
+            // Step 4: Write thresholds to .scale/thresholds.json
+            const thresholdsPath = join(args.dir, '.scale', 'thresholds.json');
+            ensureDir(join(args.dir, '.scale'));
+            writeFileSync(thresholdsPath, JSON.stringify({
+                coverage: { minimum: coverageThreshold, unit: 'percent' },
+                retry: { bruteMaximum: retryThreshold, unit: 'count' },
+                severity: { blockLevel: blockSeverity },
+                gates: {
+                    G3_build: { required: scenarioMode !== 'sandbox', exitCode: 0 },
+                    G4_lint: { required: scenarioMode !== 'sandbox', exitCode: 0 },
+                    G5_tests: { required: scenarioMode !== 'sandbox', allPass: true },
+                    G6_coverage: { required: scenarioMode !== 'sandbox', minimum: coverageThreshold },
+                    G7_security: { required: scenarioMode === 'critical', noCritical: true },
+                },
+            }, null, 2));
+            console.log(`\n   ✓ Thresholds written to: ${thresholdsPath}`);
+            // Initialize with adapter
+            const adapter = createAdapter(agentType);
+            const result = await adapter.init({
+                projectDir: args.dir,
+                agentType: agentType,
+                scenarioMode,
+                thresholdsPath,
+            });
+            const projectName = args.dir.split(/[/\\]/).pop() || 'Project';
+            const governance = writeGovernanceTemplates(args.dir, {
+                mode: governanceModeFromScenario(scenarioMode),
+                projectName,
+            });
+            result.created.push(...governance.created);
+            result.skipped.push(...governance.skipped);
+            console.log(`\n✅ SCALE Engine initialized for ${agentType} (interactive mode)`);
+            console.log(`\n📁 Created:`);
+            for (const f of result.created)
+                console.log(`   + ${f}`);
+            if (result.skipped.length > 0) {
+                console.log(`\n⏭️  Skipped (already exist):`);
+                for (const f of result.skipped)
+                    console.log(`   - ${f}`);
+            }
+            console.log(`\n🔧 Configuration Summary:`);
+            console.log(`   Settings:      ${result.settingsPath}`);
+            console.log(`   Knowledge:     ${result.knowledgeDocPath}`);
+            console.log(`   Thresholds:    ${thresholdsPath}`);
+            console.log(`   Data dir:      ${result.scaleDir}`);
+            console.log(`   Scenario:      ${scenarioMode}`);
+            console.log(`\n📋 Next steps:`);
+            console.log(`   → scale doctor`);
+            console.log(`   → scale create Spec "<feature name>"`);
+            return;
+        }
         // One-click quick start mode
         if (args.quick || !args.agent) {
             const qsResult = await quickStart(args.dir);
@@ -853,6 +1120,13 @@ const init = defineCommand({
         // Manual agent specification mode
         const adapter = createAdapter(args.agent);
         const result = await adapter.init({ projectDir: args.dir, agentType: args.agent, scenarioMode: args.scenario });
+        const projectName = args.dir.split(/[/\\]/).pop() || 'Project';
+        const governance = writeGovernanceTemplates(args.dir, {
+            mode: governanceModeFromScenario(args.scenario),
+            projectName,
+        });
+        result.created.push(...governance.created);
+        result.skipped.push(...governance.skipped);
         console.log(`\n✅ SCALE Engine initialized for ${args.agent} (scenario: ${args.scenario})`);
         console.log(`\n📁 Created:`);
         for (const f of result.created)
@@ -1115,9 +1389,117 @@ const skillScan = defineCommand({
         }
     },
 });
+const skillPlanCommand = defineCommand({
+    meta: { name: 'plan', description: 'Create or refresh a task skill plan' },
+    args: {
+        'task-id': { type: 'positional', required: true },
+        dir: { type: 'string', description: 'Task artifact directory; defaults to current state artifactsDir' },
+        json: { type: 'boolean', default: false },
+    },
+    async run({ args }) {
+        const { store } = getEngine();
+        const task = await store.get(args['task-id']);
+        if (!task || task.type !== 'Task') {
+            console.error(`Task not found: ${args['task-id']}`);
+            process.exit(1);
+        }
+        const payload = task.payload;
+        const level = normalizeTaskArtifactLevel(payload.workflowLevel ?? 'M');
+        const policy = loadSkillRoutingPolicy(PROJECT_DIR, SCALE_DIR);
+        const plan = createSkillPlan({
+            taskId: task.id,
+            taskName: task.title,
+            description: payload.description,
+            level,
+            services: payload.servicesTouched ?? [],
+            files: payload.filesInvolved ?? [],
+            policy,
+        });
+        const updatedPayload = {
+            ...payload,
+            skillIntents: plan.intents.map(intent => intent.domain),
+            skillRoutingMode: plan.mode,
+            skillPlanRequired: plan.required,
+            requiredSkills: plan.requiredSkills,
+            recommendedSkills: plan.recommendedSkills,
+            requiredSkillArtifacts: plan.requiredArtifacts,
+            requiredSkillVerification: plan.requiredVerification,
+        };
+        await store.update(task.id, { payload: updatedPayload });
+        const state = new WorkflowArtifactWriter(SCALE_DIR).readCurrentState();
+        const artifactsDir = args.dir ?? (state?.taskId === task.id ? state.artifactsDir : undefined);
+        let writtenPath;
+        if (artifactsDir) {
+            const dir = resolve(PROJECT_DIR, artifactsDir);
+            ensureDir(dir);
+            writtenPath = join(dir, 'skill-plan.md');
+            writeFileSync(writtenPath, skillPlanMarkdown(plan), 'utf-8');
+        }
+        new WorkflowArtifactWriter(SCALE_DIR).updateCurrentState({
+            taskId: task.id,
+            level,
+            phase: 'plan',
+            artifactsDir,
+            skillIntents: plan.intents.map(intent => intent.domain),
+            skillRoutingMode: plan.mode,
+            skillPlanRequired: plan.required,
+            skillPlanPath: writtenPath,
+            requiredSkills: plan.requiredSkills,
+            recommendedSkills: plan.recommendedSkills,
+            requiredSkillArtifacts: plan.requiredArtifacts,
+            requiredSkillVerification: plan.requiredVerification,
+        });
+        if (args.json) {
+            console.log(JSON.stringify({ plan, writtenPath }, null, 2));
+            return;
+        }
+        console.log('\nSkill Plan');
+        console.log(`  Task: ${task.id}`);
+        console.log(`  Intents: ${plan.intents.map(intent => intent.domain).join(', ') || 'none'}`);
+        console.log(`  Required skills: ${plan.requiredSkills.join(', ') || 'none'}`);
+        console.log(`  Recommended skills: ${plan.recommendedSkills.join(', ') || 'none'}`);
+        console.log(`  Required artifacts: ${plan.requiredArtifacts.join(', ') || 'none'}`);
+        if (writtenPath)
+            console.log(`  Written: ${writtenPath}`);
+    },
+});
+const skillCheckCommand = defineCommand({
+    meta: { name: 'check', description: 'Check required skill evidence artifacts' },
+    args: {
+        dir: { type: 'string', description: 'Task artifact directory; defaults to current state artifactsDir' },
+        level: { type: 'string', description: 'Task level: S, M, L, or CRITICAL; defaults to current state level or M' },
+        json: { type: 'boolean', default: false },
+    },
+    run({ args }) {
+        const state = new WorkflowArtifactWriter(SCALE_DIR).readCurrentState();
+        const level = normalizeTaskArtifactLevel(args.level ?? state?.level ?? 'M');
+        const policy = loadSkillRoutingPolicy(PROJECT_DIR, SCALE_DIR);
+        const result = evaluateSkillGate({
+            projectDir: PROJECT_DIR,
+            artifactsDir: args.dir ?? state?.artifactsDir,
+            level,
+            requiredArtifacts: state?.requiredSkillArtifacts,
+            mode: state?.skillRoutingMode ?? policy.policy.mode,
+            enforceLevels: policy.policy.enforceLevels,
+        });
+        if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nSkill Gate: ${result.complete ? 'COMPLETE' : 'INCOMPLETE'}`);
+        console.log(`  Mode: ${result.mode}`);
+        console.log(`  Required: ${result.required.join(', ') || 'none'}`);
+        for (const file of result.missing)
+            console.log(`  [MISSING] ${file}`);
+        for (const item of result.incomplete)
+            console.log(`  [INCOMPLETE] ${item.file}: ${item.reason}`);
+        if (result.blocked)
+            process.exitCode = 1;
+    },
+});
 const skill = defineCommand({
     meta: { name: 'skill', description: 'Skill discovery and management' },
-    subCommands: { scan: skillScan },
+    subCommands: { scan: skillScan, plan: skillPlanCommand, check: skillCheckCommand },
 });
 // ============================================================================
 // agent commands — Multi-Agent 协作系统 (Phase 9)
@@ -1242,11 +1624,16 @@ const team = defineCommand({
 // ============================================================================
 import * as phaseCommands from '../cli/phaseCommands.js';
 import * as liteCommands from '../cli/liteCommands.js';
+import * as vibeCommands from '../cli/vibeCommands.js';
 const main = defineCommand({
-    meta: { name: 'scale', version: '0.10.1', description: 'SCALE Engine v0.10.1 CLI - hardened phase workflow gates: define/plan/build/verify/review/ship; Lite Mode: scale lite; 11 agents; 10 workflows; 9 detectors' },
+    meta: { name: 'scale', version: '0.13.0', description: 'SCALE Engine v0.13.0 CLI - hardened phase workflow gates: define/plan/build/verify/review/ship; Vibe templates: scale vibe; 16 platform adapters; 12 agents; 10 workflows; 19 detectors' },
     subCommands: {
         // Lite Mode (agent-skills style interactive entry)
         lite: liteCommands.liteCommand,
+        // Vibe Templates (one-click prompt workflow)
+        vibe: vibeCommands.vibeCommand,
+        'vibe-next': vibeCommands.vibeNextCommand,
+        'vibe-index': vibeCommands.vibeIndexCommand,
         // Phase-Aligned Commands (agent-skills style)
         define: phaseCommands.phaseDefine,
         plan: phaseCommands.phasePlan,
@@ -1269,10 +1656,14 @@ const main = defineCommand({
         context,
         evolve,
         stats,
+        preflight,
+        metrics,
+        'task-artifacts': taskArtifacts,
         status,
         workflow,
         evidence,
         skill,
+        skills: skill,
         agent,
         team,
         'create-prd': createPRD,