@claude-flow/cli 3.0.0-alpha.145 → 3.0.0-alpha.147
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/commands/hooks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;
|
|
1
|
+
{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/commands/hooks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AAyjI1E,eAAO,MAAM,YAAY,EAAE,OAiG1B,CAAC;AAEF,eAAe,YAAY,CAAC"}
|
|
@@ -2725,7 +2725,59 @@ const statuslineCommand = {
|
|
|
2725
2725
|
catch {
|
|
2726
2726
|
// Ignore
|
|
2727
2727
|
}
|
|
2728
|
-
|
|
2728
|
+
// Calculate intelligence from multiple sources (matching statusline-generator.ts)
|
|
2729
|
+
let intelligencePct = 0;
|
|
2730
|
+
// 1. Check learning.json for REAL intelligence metrics first
|
|
2731
|
+
const learningJsonPaths = [
|
|
2732
|
+
path.join(process.cwd(), '.claude-flow', 'learning.json'),
|
|
2733
|
+
path.join(process.cwd(), '.claude', '.claude-flow', 'learning.json'),
|
|
2734
|
+
path.join(process.cwd(), '.swarm', 'learning.json'),
|
|
2735
|
+
];
|
|
2736
|
+
for (const lPath of learningJsonPaths) {
|
|
2737
|
+
if (fs.existsSync(lPath)) {
|
|
2738
|
+
try {
|
|
2739
|
+
const data = JSON.parse(fs.readFileSync(lPath, 'utf-8'));
|
|
2740
|
+
if (data.intelligence?.score !== undefined) {
|
|
2741
|
+
intelligencePct = Math.min(100, Math.floor(data.intelligence.score));
|
|
2742
|
+
break;
|
|
2743
|
+
}
|
|
2744
|
+
}
|
|
2745
|
+
catch { /* ignore */ }
|
|
2746
|
+
}
|
|
2747
|
+
}
|
|
2748
|
+
// 2. Fallback: calculate from patterns and vectors
|
|
2749
|
+
if (intelligencePct === 0) {
|
|
2750
|
+
const fromPatterns = learning.patterns > 0 ? Math.min(100, Math.floor(learning.patterns / 10)) : 0;
|
|
2751
|
+
// Will be updated later with vector count
|
|
2752
|
+
intelligencePct = fromPatterns;
|
|
2753
|
+
}
|
|
2754
|
+
// 3. Fallback: calculate maturity score from project indicators
|
|
2755
|
+
if (intelligencePct === 0) {
|
|
2756
|
+
let maturityScore = 0;
|
|
2757
|
+
// Check for key project files/dirs
|
|
2758
|
+
if (fs.existsSync(path.join(process.cwd(), '.claude')))
|
|
2759
|
+
maturityScore += 15;
|
|
2760
|
+
if (fs.existsSync(path.join(process.cwd(), '.claude-flow')))
|
|
2761
|
+
maturityScore += 15;
|
|
2762
|
+
if (fs.existsSync(path.join(process.cwd(), 'CLAUDE.md')))
|
|
2763
|
+
maturityScore += 10;
|
|
2764
|
+
if (fs.existsSync(path.join(process.cwd(), 'claude-flow.config.json')))
|
|
2765
|
+
maturityScore += 10;
|
|
2766
|
+
if (fs.existsSync(path.join(process.cwd(), '.swarm')))
|
|
2767
|
+
maturityScore += 10;
|
|
2768
|
+
// Check for test files
|
|
2769
|
+
const testDirs = ['tests', '__tests__', 'test', 'v3/__tests__'];
|
|
2770
|
+
for (const dir of testDirs) {
|
|
2771
|
+
if (fs.existsSync(path.join(process.cwd(), dir))) {
|
|
2772
|
+
maturityScore += 10;
|
|
2773
|
+
break;
|
|
2774
|
+
}
|
|
2775
|
+
}
|
|
2776
|
+
// Check for hooks config
|
|
2777
|
+
if (fs.existsSync(path.join(process.cwd(), '.claude', 'settings.json')))
|
|
2778
|
+
maturityScore += 10;
|
|
2779
|
+
intelligencePct = Math.min(100, maturityScore);
|
|
2780
|
+
}
|
|
2729
2781
|
const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
|
|
2730
2782
|
return { memoryMB, contextPct, intelligencePct, subAgents };
|
|
2731
2783
|
}
|
|
@@ -2804,30 +2856,179 @@ const statuslineCommand = {
|
|
|
2804
2856
|
}
|
|
2805
2857
|
header += ` ${c.dim}│${c.reset} ${c.purple}${user.modelName}${c.reset}`;
|
|
2806
2858
|
const separator = `${c.dim}─────────────────────────────────────────────────────${c.reset}`;
|
|
2859
|
+
// Get hooks stats
|
|
2860
|
+
const hooksStats = { enabled: 0, total: 17 };
|
|
2861
|
+
const settingsPath = path.join(process.cwd(), '.claude', 'settings.json');
|
|
2862
|
+
if (fs.existsSync(settingsPath)) {
|
|
2863
|
+
try {
|
|
2864
|
+
const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
|
|
2865
|
+
if (settings.hooks) {
|
|
2866
|
+
hooksStats.enabled = Object.values(settings.hooks).filter((h) => h && typeof h === 'object').length;
|
|
2867
|
+
}
|
|
2868
|
+
}
|
|
2869
|
+
catch { /* ignore */ }
|
|
2870
|
+
}
|
|
2871
|
+
// Get AgentDB stats (matching statusline-generator.ts paths)
|
|
2872
|
+
const agentdbStats = { vectorCount: 0, dbSizeKB: 0, hasHnsw: false };
|
|
2873
|
+
// Check for direct database files first
|
|
2874
|
+
const dbPaths = [
|
|
2875
|
+
path.join(process.cwd(), '.swarm', 'memory.db'),
|
|
2876
|
+
path.join(process.cwd(), '.claude-flow', 'memory.db'),
|
|
2877
|
+
path.join(process.cwd(), '.claude', 'memory.db'),
|
|
2878
|
+
path.join(process.cwd(), 'data', 'memory.db'),
|
|
2879
|
+
path.join(process.cwd(), 'memory.db'),
|
|
2880
|
+
path.join(process.cwd(), '.agentdb', 'memory.db'),
|
|
2881
|
+
path.join(process.cwd(), '.claude-flow', 'memory', 'agentdb.db'),
|
|
2882
|
+
];
|
|
2883
|
+
for (const dbPath of dbPaths) {
|
|
2884
|
+
if (fs.existsSync(dbPath)) {
|
|
2885
|
+
try {
|
|
2886
|
+
const stats = fs.statSync(dbPath);
|
|
2887
|
+
agentdbStats.dbSizeKB = Math.round(stats.size / 1024);
|
|
2888
|
+
agentdbStats.vectorCount = Math.floor(agentdbStats.dbSizeKB / 2);
|
|
2889
|
+
agentdbStats.hasHnsw = agentdbStats.vectorCount > 100;
|
|
2890
|
+
break;
|
|
2891
|
+
}
|
|
2892
|
+
catch { /* ignore */ }
|
|
2893
|
+
}
|
|
2894
|
+
}
|
|
2895
|
+
// Check for AgentDB directories if no direct db found
|
|
2896
|
+
if (agentdbStats.vectorCount === 0) {
|
|
2897
|
+
const agentdbDirs = [
|
|
2898
|
+
path.join(process.cwd(), '.claude-flow', 'agentdb'),
|
|
2899
|
+
path.join(process.cwd(), '.swarm', 'agentdb'),
|
|
2900
|
+
path.join(process.cwd(), 'data', 'agentdb'),
|
|
2901
|
+
path.join(process.cwd(), '.agentdb'),
|
|
2902
|
+
];
|
|
2903
|
+
for (const dir of agentdbDirs) {
|
|
2904
|
+
if (fs.existsSync(dir)) {
|
|
2905
|
+
try {
|
|
2906
|
+
const files = fs.readdirSync(dir);
|
|
2907
|
+
for (const f of files) {
|
|
2908
|
+
if (f.endsWith('.db') || f.endsWith('.sqlite')) {
|
|
2909
|
+
const filePath = path.join(dir, f);
|
|
2910
|
+
const fileStat = fs.statSync(filePath);
|
|
2911
|
+
agentdbStats.dbSizeKB += Math.round(fileStat.size / 1024);
|
|
2912
|
+
}
|
|
2913
|
+
}
|
|
2914
|
+
agentdbStats.vectorCount = Math.floor(agentdbStats.dbSizeKB / 2);
|
|
2915
|
+
agentdbStats.hasHnsw = agentdbStats.vectorCount > 100;
|
|
2916
|
+
if (agentdbStats.vectorCount > 0)
|
|
2917
|
+
break;
|
|
2918
|
+
}
|
|
2919
|
+
catch { /* ignore */ }
|
|
2920
|
+
}
|
|
2921
|
+
}
|
|
2922
|
+
}
|
|
2923
|
+
// Check for HNSW index files
|
|
2924
|
+
const hnswPaths = [
|
|
2925
|
+
path.join(process.cwd(), '.claude-flow', 'hnsw'),
|
|
2926
|
+
path.join(process.cwd(), '.swarm', 'hnsw'),
|
|
2927
|
+
path.join(process.cwd(), 'data', 'hnsw'),
|
|
2928
|
+
];
|
|
2929
|
+
for (const hnswPath of hnswPaths) {
|
|
2930
|
+
if (fs.existsSync(hnswPath)) {
|
|
2931
|
+
agentdbStats.hasHnsw = true;
|
|
2932
|
+
try {
|
|
2933
|
+
const hnswFiles = fs.readdirSync(hnswPath);
|
|
2934
|
+
const indexFile = hnswFiles.find(f => f.endsWith('.index'));
|
|
2935
|
+
if (indexFile) {
|
|
2936
|
+
const indexStat = fs.statSync(path.join(hnswPath, indexFile));
|
|
2937
|
+
const hnswVectors = Math.floor(indexStat.size / 512);
|
|
2938
|
+
agentdbStats.vectorCount = Math.max(agentdbStats.vectorCount, hnswVectors);
|
|
2939
|
+
}
|
|
2940
|
+
}
|
|
2941
|
+
catch { /* ignore */ }
|
|
2942
|
+
break;
|
|
2943
|
+
}
|
|
2944
|
+
}
|
|
2945
|
+
// Check for vectors.json file
|
|
2946
|
+
const vectorsPath = path.join(process.cwd(), '.claude-flow', 'vectors.json');
|
|
2947
|
+
if (fs.existsSync(vectorsPath) && agentdbStats.vectorCount === 0) {
|
|
2948
|
+
try {
|
|
2949
|
+
const data = JSON.parse(fs.readFileSync(vectorsPath, 'utf-8'));
|
|
2950
|
+
if (Array.isArray(data)) {
|
|
2951
|
+
agentdbStats.vectorCount = data.length;
|
|
2952
|
+
}
|
|
2953
|
+
else if (data.vectors) {
|
|
2954
|
+
agentdbStats.vectorCount = Object.keys(data.vectors).length;
|
|
2955
|
+
}
|
|
2956
|
+
}
|
|
2957
|
+
catch { /* ignore */ }
|
|
2958
|
+
}
|
|
2959
|
+
// Get test stats
|
|
2960
|
+
const testStats = { testFiles: 0, testCases: 0 };
|
|
2961
|
+
const testPaths = ['tests', '__tests__', 'test', 'spec'];
|
|
2962
|
+
for (const testPath of testPaths) {
|
|
2963
|
+
const fullPath = path.join(process.cwd(), testPath);
|
|
2964
|
+
if (fs.existsSync(fullPath)) {
|
|
2965
|
+
try {
|
|
2966
|
+
const files = fs.readdirSync(fullPath, { recursive: true });
|
|
2967
|
+
testStats.testFiles = files.filter((f) => /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(f)).length;
|
|
2968
|
+
testStats.testCases = testStats.testFiles * 28; // Estimate
|
|
2969
|
+
}
|
|
2970
|
+
catch { /* ignore */ }
|
|
2971
|
+
}
|
|
2972
|
+
}
|
|
2973
|
+
// Get MCP stats
|
|
2974
|
+
const mcpStats = { enabled: 0, total: 0 };
|
|
2975
|
+
const mcpPath = path.join(process.cwd(), '.mcp.json');
|
|
2976
|
+
if (fs.existsSync(mcpPath)) {
|
|
2977
|
+
try {
|
|
2978
|
+
const mcp = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
|
|
2979
|
+
if (mcp.mcpServers) {
|
|
2980
|
+
mcpStats.total = Object.keys(mcp.mcpServers).length;
|
|
2981
|
+
mcpStats.enabled = mcpStats.total;
|
|
2982
|
+
}
|
|
2983
|
+
}
|
|
2984
|
+
catch { /* ignore */ }
|
|
2985
|
+
}
|
|
2807
2986
|
const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
|
|
2987
|
+
// Dynamic perf indicator based on patterns/HNSW
|
|
2988
|
+
let perfIndicator = `${c.dim}⚡ target: 150x-12500x${c.reset}`;
|
|
2989
|
+
if (agentdbStats.hasHnsw && agentdbStats.vectorCount > 0) {
|
|
2990
|
+
const speedup = agentdbStats.vectorCount > 10000 ? '12500x' : agentdbStats.vectorCount > 1000 ? '150x' : '10x';
|
|
2991
|
+
perfIndicator = `${c.brightGreen}⚡ HNSW ${speedup}${c.reset}`;
|
|
2992
|
+
}
|
|
2993
|
+
else if (progress.patternsLearned > 0) {
|
|
2994
|
+
const patternsK = progress.patternsLearned >= 1000 ? `${(progress.patternsLearned / 1000).toFixed(1)}k` : String(progress.patternsLearned);
|
|
2995
|
+
perfIndicator = `${c.brightYellow}📚 ${patternsK} patterns${c.reset}`;
|
|
2996
|
+
}
|
|
2808
2997
|
const line1 = `${c.brightCyan}🏗️ DDD Domains${c.reset} ${progressBar(progress.domainsCompleted, progress.totalDomains)} ` +
|
|
2809
2998
|
`${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset} ` +
|
|
2810
|
-
|
|
2999
|
+
perfIndicator;
|
|
2811
3000
|
const swarmIndicator = swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
|
|
2812
3001
|
const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
|
|
2813
3002
|
const securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'IN_PROGRESS' ? '🟡' : '🔴';
|
|
2814
3003
|
const securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;
|
|
3004
|
+
const hooksColor = hooksStats.enabled > 0 ? c.brightGreen : c.dim;
|
|
2815
3005
|
const line2 = `${c.brightYellow}🤖 Swarm${c.reset} ${swarmIndicator} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}] ` +
|
|
2816
3006
|
`${c.brightPurple}👥 ${system.subAgents}${c.reset} ` +
|
|
3007
|
+
`${c.brightBlue}🪝 ${hooksColor}${hooksStats.enabled}${c.reset}/${c.brightWhite}${hooksStats.total}${c.reset} ` +
|
|
2817
3008
|
`${securityIcon} ${securityColor}CVE ${security.cvesFixed}${c.reset}/${c.brightWhite}${security.totalCves}${c.reset} ` +
|
|
2818
3009
|
`${c.brightCyan}💾 ${system.memoryMB}MB${c.reset} ` +
|
|
2819
|
-
`${c.brightGreen}📂 ${String(system.contextPct).padStart(3)}%${c.reset} ` +
|
|
2820
3010
|
`${c.brightPurple}🧠 ${String(system.intelligencePct).padStart(3)}%${c.reset}`;
|
|
2821
|
-
const
|
|
2822
|
-
|
|
2823
|
-
|
|
2824
|
-
|
|
2825
|
-
|
|
3011
|
+
const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;
|
|
3012
|
+
const line3 = `${c.brightPurple}🔧 Architecture${c.reset} ` +
|
|
3013
|
+
`${c.cyan}ADRs${c.reset} ${c.dim}●0/0${c.reset} ${c.dim}│${c.reset} ` +
|
|
3014
|
+
`${c.cyan}DDD${c.reset} ${dddColor}●${String(progress.dddProgress).padStart(3)}%${c.reset} ${c.dim}│${c.reset} ` +
|
|
3015
|
+
`${c.cyan}Security${c.reset} ${securityColor}●${security.status}${c.reset}`;
|
|
3016
|
+
const vectorColor = agentdbStats.vectorCount > 0 ? c.brightGreen : c.dim;
|
|
3017
|
+
const testColor = testStats.testFiles > 0 ? c.brightGreen : c.dim;
|
|
3018
|
+
const mcpColor = mcpStats.enabled > 0 ? c.brightGreen : c.dim;
|
|
3019
|
+
const sizeDisplay = agentdbStats.dbSizeKB >= 1024 ? `${(agentdbStats.dbSizeKB / 1024).toFixed(1)}MB` : `${agentdbStats.dbSizeKB}KB`;
|
|
3020
|
+
const hnswIndicator = agentdbStats.hasHnsw ? `${c.brightGreen}⚡${c.reset}` : '';
|
|
3021
|
+
const line4 = `${c.brightCyan}📊 AgentDB${c.reset} ` +
|
|
3022
|
+
`${c.cyan}Vectors${c.reset} ${vectorColor}●${agentdbStats.vectorCount}${hnswIndicator}${c.reset} ${c.dim}│${c.reset} ` +
|
|
3023
|
+
`${c.cyan}Size${c.reset} ${c.brightWhite}${sizeDisplay}${c.reset} ${c.dim}│${c.reset} ` +
|
|
3024
|
+
`${c.cyan}Tests${c.reset} ${testColor}●${testStats.testFiles}${c.reset} ${c.dim}(${testStats.testCases} cases)${c.reset} ${c.dim}│${c.reset} ` +
|
|
3025
|
+
`${c.cyan}MCP${c.reset} ${mcpColor}●${mcpStats.enabled}/${mcpStats.total}${c.reset}`;
|
|
2826
3026
|
output.writeln(header);
|
|
2827
3027
|
output.writeln(separator);
|
|
2828
3028
|
output.writeln(line1);
|
|
2829
3029
|
output.writeln(line2);
|
|
2830
3030
|
output.writeln(line3);
|
|
3031
|
+
output.writeln(line4);
|
|
2831
3032
|
return { success: true, data: statusData };
|
|
2832
3033
|
}
|
|
2833
3034
|
};
|