@hongmaple0820/scale-engine 0.33.0 → 0.39.0

package/dist/api/doctor.d.ts

@@ -1,25 +1,46 @@
+import { type ProfileBootstrapPlan } from '../config/profiles.js';
+import { execSync } from 'node:child_process';
+import { inspectCodeIntelligence } from '../codegraph/CodeIntelligence.js';
+import { inspectMemoryProviders } from '../memory/MemoryProviders.js';
+import { inspectToolCapabilities } from '../tools/ToolCapabilityRegistry.js';
 export interface DiagnosticResult {
     name: string;
     status: 'ok' | 'warn' | 'fail';
     message: string;
     fix?: string;
     optional?: boolean;
-    category?: 'governance' | 'knowledge-graph' | 'runtime';
+    category?: 'governance' | 'knowledge-graph' | 'runtime' | 'memory';
 }
 export interface DoctorReport {
     overall: 'healthy' | 'degraded' | 'broken';
     checks: DiagnosticResult[];
     timestamp: number;
+    bootstrapPlan?: ProfileBootstrapPlan;
     knowledgeGraph?: {
         available: boolean;
         pythonVersion?: string;
         graphifyInstalled?: boolean;
+        codegraphInstalled?: boolean;
+        codegraphProjectInitialized?: boolean;
     };
+    memoryProviders?: {
+        available: boolean;
+        gbrainAvailable: boolean;
+        defaultOrder: string[];
+        mode: string;
+    };
+}
+interface DoctorDeps {
+    execSyncImpl?: typeof execSync;
+    inspectCodeIntelligenceImpl?: typeof inspectCodeIntelligence;
+    inspectMemoryProvidersImpl?: typeof inspectMemoryProviders;
+    inspectToolCapabilitiesImpl?: typeof inspectToolCapabilities;
 }
 export declare class Doctor {
     private projectDir;
     private scaleDir;
-    constructor(projectDir?: string, scaleDir?: string);
+    private deps;
+    constructor(projectDir?: string, scaleDir?: string, deps?: DoctorDeps);
     diagnose(): Promise<DoctorReport>;
     private checkScaleDir;
     private checkEventsDir;
@@ -41,8 +62,22 @@ export declare class Doctor {
     private skippedEngineeringStandardsForWorkspaceConflict;
     private checkGovernanceDrift;
     private checkPython;
-    private checkGraphify;
+    private checkGraphifyCli;
+    private checkGraphifyArtifact;
+    private checkCodegraph;
+    private checkCodegraphProject;
+    private checkMemoryProviders;
     private checkRuntimeEvidence;
     private checkConfigHealth;
+    private resolveBootstrapPlan;
+    private readProfileId;
+    private inspectCodeIntelligence;
+    private inspectMemoryProviders;
+    private inspectToolCapabilities;
+    private runExecSync;
+    private knowledgeBootstrapApplyCommand;
+    private memoryBootstrapApplyCommand;
     formatReport(report: DoctorReport): string;
+    private formatReportAscii;
 }
+export {};

package/dist/api/doctor.js

@@ -2,7 +2,7 @@
 // 环境诊断 + 健康检查
 // Usage: scale doctor
 import { existsSync, readdirSync, statSync, readFileSync } from 'node:fs';
-import { getProfile } from '../config/profiles.js';
+import { getBootstrapPlanForProfile, getProfile } from '../config/profiles.js';
 import { join } from 'node:path';
 import { execSync } from 'node:child_process';
 import { computeGovernanceDrift } from '../workflow/GovernanceLock.js';
@@ -10,13 +10,21 @@ import { doctorEngineeringStandards } from '../workflow/EngineeringStandards.js'
 import { doctorResourceAssets } from '../workflow/ResourceGovernance.js';
 import { doctorRuntimeEvidence } from '../runtime/RuntimeDoctor.js';
 import { inspectWorkspaceSafety } from '../workflow/WorkspaceSafety.js';
+import { inspectCodeIntelligence } from '../codegraph/CodeIntelligence.js';
+import { inspectMemoryProviders } from '../memory/MemoryProviders.js';
+import { inspectToolCapabilities } from '../tools/ToolCapabilityRegistry.js';
 export class Doctor {
-    constructor(projectDir = '.', scaleDir = '.scale') {
+    constructor(projectDir = '.', scaleDir = '.scale', deps = {}) {
         this.projectDir = projectDir;
         this.scaleDir = scaleDir;
+        this.deps = deps;
     }
     async diagnose() {
         const checks = [];
+        const bootstrapPlan = this.resolveBootstrapPlan();
+        const codeIntelligence = this.inspectCodeIntelligence();
+        const memoryProviders = this.inspectMemoryProviders();
+        const toolCapabilities = this.inspectToolCapabilities(['graphify', 'codegraph', 'gbrain']);
         checks.push(this.checkScaleDir());
         checks.push(this.checkEventsDir());
         checks.push(this.checkArtifactsDir());
@@ -68,14 +76,30 @@ export class Doctor {
         configHealthCheck.category = 'governance';
         checks.push(configHealthCheck);
         // Optional knowledge graph checks (non-blocking)
-        const pythonCheck = this.checkPython();
-        const graphifyCheck = this.checkGraphify();
+        const pythonCheck = this.checkPython(bootstrapPlan);
+        const graphifyCheck = this.checkGraphifyCli(toolCapabilities, bootstrapPlan);
+        const graphifyArtifactCheck = this.checkGraphifyArtifact(codeIntelligence);
+        const codegraphCheck = this.checkCodegraph(toolCapabilities, bootstrapPlan);
+        const codegraphProjectCheck = this.checkCodegraphProject(codeIntelligence);
+        const memoryRoutingCheck = this.checkMemoryProviders(memoryProviders, bootstrapPlan);
         pythonCheck.optional = true;
         graphifyCheck.optional = true;
+        graphifyArtifactCheck.optional = true;
+        codegraphCheck.optional = true;
+        codegraphProjectCheck.optional = true;
+        memoryRoutingCheck.optional = true;
         pythonCheck.category = 'knowledge-graph';
         graphifyCheck.category = 'knowledge-graph';
+        graphifyArtifactCheck.category = 'knowledge-graph';
+        codegraphCheck.category = 'knowledge-graph';
+        codegraphProjectCheck.category = 'knowledge-graph';
+        memoryRoutingCheck.category = 'memory';
         checks.push(pythonCheck);
         checks.push(graphifyCheck);
+        checks.push(graphifyArtifactCheck);
+        checks.push(codegraphCheck);
+        checks.push(codegraphProjectCheck);
+        checks.push(memoryRoutingCheck);
         // Calculate overall health excluding optional checks
         const coreChecks = checks.filter((c) => !c.optional);
         const fails = coreChecks.filter((c) => c.status === 'fail').length;
@@ -83,11 +107,25 @@ export class Doctor {
         const overall = fails > 0 ? 'broken' : warns > 0 ? 'degraded' : 'healthy';
         // Knowledge graph availability metadata
         const knowledgeGraph = {
-            available: pythonCheck.status === 'ok' && graphifyCheck.status === 'ok',
+            available: graphifyArtifactCheck.status === 'ok' || codegraphProjectCheck.status === 'ok',
             pythonVersion: pythonCheck.status === 'ok' ? pythonCheck.message : undefined,
             graphifyInstalled: graphifyCheck.status === 'ok',
+            codegraphInstalled: codegraphCheck.status === 'ok',
+            codegraphProjectInitialized: codegraphProjectCheck.status === 'ok',
+        };
+        return {
+            overall,
+            checks,
+            timestamp: Date.now(),
+            bootstrapPlan,
+            knowledgeGraph,
+            memoryProviders: {
+                available: memoryProviders.availableProviderCount > 0,
+                gbrainAvailable: Boolean(memoryProviders.providers.find(provider => provider.id === 'gbrain')?.available),
+                defaultOrder: [...memoryProviders.routing.defaultOrder],
+                mode: memoryProviders.routing.mode,
+            },
         };
-        return { overall, checks, timestamp: Date.now(), knowledgeGraph };
     }
     checkScaleDir() {
         const dir = join(this.projectDir, this.scaleDir);
@@ -159,7 +197,27 @@ export class Doctor {
         }
         try {
             const content = JSON.parse(readFileSync(found.path, 'utf-8'));
-            const hasScaleHooks = JSON.stringify(content).includes('scale ');
+            const collectHookEntries = (entries) => {
+                const flattened = [];
+                for (const entry of entries) {
+                    if (!entry || typeof entry !== 'object')
+                        continue;
+                    flattened.push(entry);
+                    if (Array.isArray(entry.hooks)) {
+                        flattened.push(...collectHookEntries(entry.hooks ?? []));
+                    }
+                }
+                return flattened;
+            };
+            const hookEntries = collectHookEntries(Object.values(content.hooks ?? {}).flatMap((value) => Array.isArray(value) ? value : []));
+            const hasScaleHooks = hookEntries.some((entry) => {
+                const command = typeof entry.command === 'string' ? entry.command : '';
+                const description = typeof entry.description === 'string' ? entry.description : '';
+                return /(^|\s)scale\s/.test(command)
+                    || command.includes('.claude/hooks/')
+                    || command.includes('scripts/hooks/')
+                    || /scale|workflow/i.test(description);
+            });
             if (!hasScaleHooks) {
                 return {
                     name: 'Agent settings',
@@ -522,9 +580,9 @@ export class Doctor {
             message: `${drift.clean.length} generated governance files clean`,
         };
     }
-    checkPython() {
+    checkPython(bootstrapPlan) {
         try {
-            const version = execSync('python3 --version', { encoding: 'utf-8', timeout: 5000 }).trim();
+            const version = this.runExecSync('python3 --version').trim();
             const match = version.match(/Python (\d+)\.(\d+)/);
             if (match) {
                 const major = parseInt(match[1]);
@@ -539,7 +597,7 @@ export class Doctor {
         catch {
             // Try python (without 3) for Windows
             try {
-                const version = execSync('python --version', { encoding: 'utf-8', timeout: 5000 }).trim();
+                const version = this.runExecSync('python --version').trim();
                 return { name: 'Python version', status: 'ok', message: version };
             }
             catch {
@@ -547,35 +605,74 @@ export class Doctor {
                     name: 'Python version',
                     status: 'warn',
                     message: 'Not installed — knowledge graph requires Python',
-                    fix: 'Install Python 3.8+ or skip with --no-knowledge-graph',
+                    fix: `Install Python 3.8+, then run: ${this.knowledgeBootstrapApplyCommand(bootstrapPlan)}`,
                 };
             }
         }
     }
-    checkGraphify() {
-        try {
-            const result = execSync('pip show graphifyy', { encoding: 'utf-8', timeout: 5000 });
-            const match = result.match(/Version: (\S+)/);
-            if (match) {
-                return { name: 'Graphify', status: 'ok', message: `graphifyy v${match[1]} installed` };
-            }
-            return { name: 'Graphify', status: 'ok', message: 'installed' };
+    checkGraphifyCli(toolCapabilities, bootstrapPlan) {
+        const graphify = toolCapabilities.tools.find(tool => tool.id === 'graphify');
+        if (graphify?.installed) {
+            return { name: 'Graphify CLI', status: 'ok', message: graphify.version ?? graphify.detectedPath ?? 'installed' };
         }
-        catch {
-            // Try pip3
-            try {
-                execSync('pip3 show graphifyy', { encoding: 'utf-8', timeout: 5000 });
-                return { name: 'Graphify', status: 'ok', message: 'installed (pip3)' };
-            }
-            catch {
-                return {
-                    name: 'Graphify',
-                    status: 'warn',
-                    message: 'Not installed — code knowledge graph optional',
-                    fix: 'pip install graphifyy && graphify install',
-                };
-            }
+        return {
+            name: 'Graphify CLI',
+            status: 'warn',
+            message: graphify?.missingReason ?? 'Graphify CLI is not installed',
+            fix: `Run: ${this.knowledgeBootstrapApplyCommand(bootstrapPlan)}`,
+        };
+    }
+    checkGraphifyArtifact(codeIntelligence) {
+        const graphify = codeIntelligence.providers.find(provider => provider.id === 'graphify');
+        if (graphify?.available) {
+            return { name: 'Graphify artifact', status: 'ok', message: graphify.reason };
+        }
+        return {
+            name: 'Graphify artifact',
+            status: 'warn',
+            message: graphify?.reason ?? 'Graphify artifact is not available',
+            fix: 'Run: scale codegraph status --json and generate graphify-out/graph.json before relying on graph-backed knowledge recall',
+        };
+    }
+    checkCodegraph(toolCapabilities, bootstrapPlan) {
+        const codegraph = toolCapabilities.tools.find(tool => tool.id === 'codegraph');
+        if (codegraph?.installed) {
+            return { name: 'CodeGraph CLI', status: 'ok', message: codegraph.version ?? codegraph.detectedPath ?? 'installed' };
+        }
+        return {
+            name: 'CodeGraph CLI',
+            status: 'warn',
+            message: codegraph?.missingReason ?? 'CodeGraph CLI is not installed',
+            fix: `Run: ${this.knowledgeBootstrapApplyCommand(bootstrapPlan)}`,
+        };
+    }
+    checkCodegraphProject(codeIntelligence) {
+        if (codeIntelligence.projectIndexExists) {
+            return { name: 'CodeGraph project index', status: 'ok', message: `Found at ${codeIntelligence.projectIndexPath}` };
+        }
+        return {
+            name: 'CodeGraph project index',
+            status: 'warn',
+            message: 'Project is not initialized for CodeGraph',
+            fix: 'Run: scale codegraph init',
+        };
+    }
+    checkMemoryProviders(memoryProviders, bootstrapPlan) {
+        const gbrain = memoryProviders.providers.find(provider => provider.id === 'gbrain');
+        if (gbrain?.available) {
+            return {
+                name: 'Memory provider routing',
+                status: memoryProviders.warnings.length > 0 ? 'warn' : 'ok',
+                message: `mode=${memoryProviders.routing.mode}; order=${memoryProviders.routing.defaultOrder.join(' -> ')}; gbrain=available`,
+                fix: memoryProviders.warnings.length > 0 ? 'Run: scale memory provider status --json' : undefined,
+            };
         }
+        return {
+            name: 'Memory provider routing',
+            status: 'warn',
+            message: `mode=${memoryProviders.routing.mode}; order=${memoryProviders.routing.defaultOrder.join(' -> ')}; gbrain=unavailable`,
+            fix: `Run: ${this.memoryBootstrapApplyCommand(bootstrapPlan)}`,
+        };
     }
     checkRuntimeEvidence() {
         try {
@@ -627,21 +724,20 @@ export class Doctor {
             const profileMatch = content.match(/^profile:\s*(.+)$/m);
             const profileId = profileMatch?.[1]?.trim() || 'standard';
             const profile = getProfile(profileId);
+            const bootstrapPlan = getBootstrapPlanForProfile(profile.id);
             if (profile.id !== profileId) {
                 issues.push(`Unknown profile "${profileId}", falling back to standard`);
             }
-            // Check vector search config without Qdrant
+            // Check legacy vector-search config drift
             if (content.includes('backend: qdrant')) {
-                try {
-                    execSync('curl -s http://localhost:6333/readyz', { timeout: 3000, stdio: 'pipe' });
-                }
-                catch {
-                    issues.push('Vector search configured with Qdrant, but Qdrant is not reachable at localhost:6333');
-                }
+                issues.push('Legacy Qdrant backend configured; default knowledge and recall flow now expects graphify + codegraph instead of Qdrant');
+                recommendations.push('Update .scale/config.yaml to use graphify-backed knowledge, or rerun: scale config profile --set advanced');
             }
             // Check evolution enabled without eval setup
             if (content.includes('evolution:') && content.includes('enabled: true')) {
-                const evalPath = join(this.projectDir, this.scaleDir, 'eval');
+                const evalPath = existsSync(join(this.projectDir, this.scaleDir, 'evals'))
+                    ? join(this.projectDir, this.scaleDir, 'evals')
+                    : join(this.projectDir, this.scaleDir, 'eval');
                 if (!existsSync(evalPath)) {
                     recommendations.push('Evolution enabled but no .scale/eval/ directory — run: scale eval init');
                 }
@@ -662,6 +758,9 @@ export class Doctor {
                     void error;
                 }
             }
+            if (bootstrapPlan.packs.length > 0 && profile.defaults.knowledge.enabled) {
+                recommendations.push(`Bootstrap profile-aligned dependencies with: ${bootstrapPlan.inspectCommand}`);
+            }
             if (issues.length > 0) {
                 return {
                     name: 'Config health',
@@ -687,7 +786,55 @@ export class Doctor {
             };
         }
     }
+    resolveBootstrapPlan() {
+        return getBootstrapPlanForProfile(this.readProfileId());
+    }
+    readProfileId() {
+        const configPath = join(this.projectDir, this.scaleDir, 'config.yaml');
+        if (!existsSync(configPath))
+            return 'standard';
+        try {
+            const content = readFileSync(configPath, 'utf-8');
+            const match = content.match(/^profile:\s*(.+)$/m);
+            return match?.[1]?.trim() || 'standard';
+        }
+        catch {
+            return 'standard';
+        }
+    }
+    inspectCodeIntelligence() {
+        return (this.deps.inspectCodeIntelligenceImpl ?? inspectCodeIntelligence)({
+            projectDir: this.projectDir,
+            scaleDir: this.scaleDir,
+        });
+    }
+    inspectMemoryProviders() {
+        return (this.deps.inspectMemoryProvidersImpl ?? inspectMemoryProviders)({
+            projectDir: this.projectDir,
+            scaleDir: this.scaleDir,
+        });
+    }
+    inspectToolCapabilities(toolIds) {
+        return (this.deps.inspectToolCapabilitiesImpl ?? inspectToolCapabilities)({
+            projectDir: this.projectDir,
+            toolIds,
+        });
+    }
+    runExecSync(command) {
+        return String((this.deps.execSyncImpl ?? execSync)(command, { encoding: 'utf-8', timeout: 5000 }));
+    }
+    knowledgeBootstrapApplyCommand(bootstrapPlan) {
+        return bootstrapPlan.packs.includes('knowledge')
+            ? bootstrapPlan.applyCommand
+            : 'scale bootstrap deps --pack knowledge --apply';
+    }
+    memoryBootstrapApplyCommand(bootstrapPlan) {
+        return bootstrapPlan.packs.includes('memory')
+            ? bootstrapPlan.applyCommand
+            : 'scale bootstrap deps --pack memory --apply';
+    }
     formatReport(report) {
+        return this.formatReportAscii(report);
         const icon = { healthy: '✅', degraded: '⚠️', broken: '❌' };
         const statusIcon = { ok: '✅', warn: '⚠️', fail: '❌' };
         const lines = [
@@ -722,16 +869,33 @@ export class Doctor {
                     lines.push(`     💡 Fix: ${check.fix}`);
             }
         }
+        const memoryChecks = report.checks.filter((c) => c.optional && c.category === 'memory');
+        if (memoryChecks.length > 0) {
+            lines.push('');
+            lines.push('Memory Providers (Optional):');
+            for (const check of memoryChecks) {
+                lines.push(`  ${statusIcon[check.status]} ${check.name}: ${check.message}`);
+                if (check.fix)
+                    lines.push(`     Fix: ${check.fix}`);
+            }
+        }
         // Knowledge graph status summary
         if (report.knowledgeGraph) {
+            const knowledgeGraph = report.knowledgeGraph;
             lines.push('');
-            if (report.knowledgeGraph.available) {
+            if (knowledgeGraph.available) {
                 lines.push('  ✅ Code knowledge graph available');
-                lines.push('  → Use: scale graphify .');
+                if (knowledgeGraph.codegraphProjectInitialized) {
+                    lines.push('  → Use: scale codegraph context --symbol <Symbol>');
+                }
+                if (knowledgeGraph.graphifyInstalled) {
+                    lines.push('  → Use: scale graphify .');
+                }
             }
             else {
                 lines.push('  ⚠️ Code knowledge graph not available (optional feature)');
-                lines.push('  → Install: pip install graphifyy && graphify install');
+                lines.push('  → Install CodeGraph: npx @colbymchenry/codegraph');
+                lines.push('  → Install Graphify: pip install graphify && graphify install');
             }
             lines.push(`${'─'.repeat(50)}`);
         }
@@ -753,5 +917,66 @@ export class Doctor {
         lines.push(`  ${ok} passed, ${warn} warnings, ${fail} failures (${optional} optional)`);
         return lines.join('\n');
     }
+    formatReportAscii(report) {
+        const icon = { healthy: '[OK]', degraded: '[WARN]', broken: '[FAIL]' };
+        const statusIcon = { ok: '[OK]', warn: '[WARN]', fail: '[FAIL]' };
+        const divider = '-'.repeat(50);
+        const lines = [
+            '',
+            `${icon[report.overall]} SCALE Engine Health: ${report.overall.toUpperCase()}`,
+            divider,
+        ];
+        for (const check of report.checks.filter((c) => !c.optional)) {
+            lines.push(`  ${statusIcon[check.status]} ${check.name}: ${check.message}`);
+            if (check.fix)
+                lines.push(`     Fix: ${check.fix}`);
+        }
+        lines.push(divider);
+        const appendSection = (title, category) => {
+            const sectionChecks = report.checks.filter((c) => c.optional && c.category === category);
+            if (sectionChecks.length === 0)
+                return;
+            lines.push('');
+            lines.push(title);
+            for (const check of sectionChecks) {
+                lines.push(`  ${statusIcon[check.status]} ${check.name}: ${check.message}`);
+                if (check.fix)
+                    lines.push(`     Fix: ${check.fix}`);
+            }
+        };
+        appendSection('Project Governance (Optional):', 'governance');
+        appendSection('Knowledge Graph (Optional):', 'knowledge-graph');
+        appendSection('Memory Providers (Optional):', 'memory');
+        appendSection('Runtime Evidence (Optional):', 'runtime');
+        if (report.knowledgeGraph) {
+            const knowledgeGraph = report.knowledgeGraph;
+            lines.push('');
+            if (knowledgeGraph.available) {
+                lines.push('  [OK] Code knowledge graph available');
+                if (report.knowledgeGraph.codegraphProjectInitialized) {
+                    lines.push('  -> Use: scale codegraph context --symbol <Symbol>');
+                }
+                if (report.knowledgeGraph.graphifyInstalled) {
+                    lines.push('  -> Use: scale graphify .');
+                }
+            }
+            else {
+                lines.push('  [WARN] Code knowledge graph not available (optional feature)');
+                lines.push(`  -> Bootstrap inspect: ${report.bootstrapPlan?.inspectCommand ?? 'scale bootstrap deps --pack knowledge --json'}`);
+                lines.push(`  -> Bootstrap apply: ${report.bootstrapPlan?.packs.includes('knowledge') ? report.bootstrapPlan.applyCommand : 'scale bootstrap deps --pack knowledge --apply'}`);
+            }
+            lines.push(divider);
+        }
+        if (report.memoryProviders && !report.memoryProviders.gbrainAvailable) {
+            lines.push(`  -> Memory bootstrap: ${report.bootstrapPlan?.packs.includes('memory') ? report.bootstrapPlan.applyCommand : 'scale bootstrap deps --pack memory --apply'}`);
+            lines.push(divider);
+        }
+        const ok = report.checks.filter((c) => c.status === 'ok').length;
+        const warn = report.checks.filter((c) => c.status === 'warn').length;
+        const fail = report.checks.filter((c) => c.status === 'fail').length;
+        const optional = report.checks.filter((c) => c.optional).length;
+        lines.push(`  ${ok} passed, ${warn} warnings, ${fail} failures (${optional} optional)`);
+        return lines.join('\n');
+    }
 }
 //# sourceMappingURL=doctor.js.map