mirror of
https://github.com/rohitg00/skillkit.git
synced 2026-11-20 12:23:29 +00:00
* feat(core): add QMD-inspired hybrid search pipeline Implement a hybrid search system combining vector embeddings with keyword search: - Vector embeddings using node-llama-cpp with GGUF models (nomic-embed-text) - RRF (Reciprocal Rank Fusion) for combining multiple rankers - Query expansion with LLM and synonym fallback - Position-aware score blending (different weights for top3, top10, rest) - SQLite storage with sqlite-vec extension (falls back to in-memory) - Auto-download of local GGUF models (~2GB) New search module: - embeddings.ts: Vector embedding generation service - vector-store.ts: SQLite-based vector storage - rrf.ts: RRF fusion algorithm - expansion.ts: Query expansion with caching - hybrid.ts: Main hybrid search pipeline - local-models.ts: GGUF model management CLI integration: - skillkit recommend --hybrid: Enable hybrid search - skillkit recommend --expand: Enable query expansion - skillkit recommend --rerank: Enable LLM re-ranking - skillkit recommend --build-index: Build embedding index Tests: 56 new tests for search module (all passing) * fix(search): address CodeRabbit review findings - Add missing beforeEach import in embeddings.test.ts - Update optional dependencies to current versions - Fix weights/variations length mismatch in expansion.ts - Avoid mutating input arrays in rrf.ts mergeRankings - Delete orphaned chunk vectors in vector-store.ts delete() and clear() - Add comment for empty catch block in vector-store.ts - Make hybridSearch helper use buildIndex for true hybrid search - Handle graceful degradation when embeddings unavailable - Add node-llama-cpp mock in hybrid.test.ts * fix(search): address CodeRabbit review round 2 - Fix gemma GGUF URL to point to valid community repo (bartowski) - Add SQL injection protection for table names in vector-store.ts - Fix resource leak with try/finally in hybridSearch helper - Add backpressure handling for large model downloads - Clamp startLine to non-negative in chunk calculation - Add runtime validation warning for --expand/--rerank without --hybrid - Update node-llama-cpp API usage (createEmbeddingContext, createContext) - Update pnpm-lock.yaml for new optional dependency versions * fix(search): use @ts-ignore for optional node-llama-cpp imports CI doesn't install optional dependencies, so @ts-ignore is needed instead of @ts-expect-error to suppress module not found errors.
734 lines
23 KiB
TypeScript
734 lines
23 KiB
TypeScript
import { Command, Option } from 'clipanion';
|
|
import { resolve } from 'node:path';
|
|
import {
|
|
type ProjectProfile,
|
|
type ScoredSkill,
|
|
type ExplainedScoredSkill,
|
|
ContextManager,
|
|
RecommendationEngine,
|
|
ReasoningRecommendationEngine,
|
|
buildSkillIndex,
|
|
saveIndex,
|
|
loadIndex as loadIndexFromCache,
|
|
isIndexStale,
|
|
INDEX_PATH,
|
|
KNOWN_SKILL_REPOS,
|
|
} from '@skillkit/core';
|
|
import {
|
|
header,
|
|
colors,
|
|
symbols,
|
|
spinner,
|
|
warn,
|
|
showProjectSummary,
|
|
progressBar,
|
|
formatQualityBadge,
|
|
getQualityGradeFromScore,
|
|
} from '../onboarding/index.js';
|
|
|
|
export class RecommendCommand extends Command {
|
|
static override paths = [['recommend'], ['rec']];
|
|
|
|
static override usage = Command.Usage({
|
|
description: 'Get skill recommendations based on your project',
|
|
details: `
|
|
The recommend command analyzes your project and suggests skills that match
|
|
your technology stack, frameworks, and patterns.
|
|
|
|
It scores skills based on:
|
|
- Framework compatibility (React, Vue, Next.js, etc.)
|
|
- Language match (TypeScript, Python, etc.)
|
|
- Library alignment (Tailwind, Prisma, etc.)
|
|
- Tag relevance
|
|
- Popularity and quality metrics
|
|
|
|
Run "skillkit recommend --update" to refresh the skill index from known sources.
|
|
`,
|
|
examples: [
|
|
['Get recommendations', '$0 recommend'],
|
|
['Show top 5 recommendations', '$0 recommend --limit 5'],
|
|
['Filter by category', '$0 recommend --category security'],
|
|
['Show detailed reasons', '$0 recommend --verbose'],
|
|
['Update skill index', '$0 recommend --update'],
|
|
['Search for skills by task', '$0 recommend --task "authentication"'],
|
|
['Search for skills (alias)', '$0 recommend --search "testing"'],
|
|
['Hybrid search (vector + keyword)', '$0 recommend --search "auth" --hybrid'],
|
|
['Hybrid search with query expansion', '$0 recommend --search "auth" --hybrid --expand'],
|
|
['Build hybrid search index', '$0 recommend --build-index'],
|
|
],
|
|
});
|
|
|
|
// Limit number of results
|
|
limit = Option.String('--limit,-l', {
|
|
description: 'Maximum number of recommendations',
|
|
});
|
|
|
|
// Minimum score threshold
|
|
minScore = Option.String('--min-score', {
|
|
description: 'Minimum match score (0-100)',
|
|
});
|
|
|
|
// Filter by category/tag
|
|
category = Option.Array('--category,-c', {
|
|
description: 'Filter by category (can be used multiple times)',
|
|
});
|
|
|
|
// Verbose output with reasons
|
|
verbose = Option.Boolean('--verbose,-v', false, {
|
|
description: 'Show detailed match reasons',
|
|
});
|
|
|
|
// Update index
|
|
update = Option.Boolean('--update,-u', false, {
|
|
description: 'Update skill index from sources',
|
|
});
|
|
|
|
// Search mode (--search or --task)
|
|
search = Option.String('--search,-s', {
|
|
description: 'Search skills by task/query',
|
|
});
|
|
|
|
// Task alias for search (GSD-style)
|
|
task = Option.String('--task,-t', {
|
|
description: 'Search skills by task (alias for --search)',
|
|
});
|
|
|
|
// Include installed skills
|
|
includeInstalled = Option.Boolean('--include-installed', false, {
|
|
description: 'Include already installed skills',
|
|
});
|
|
|
|
// JSON output
|
|
json = Option.Boolean('--json,-j', false, {
|
|
description: 'Output in JSON format',
|
|
});
|
|
|
|
// Project path
|
|
projectPath = Option.String('--path,-p', {
|
|
description: 'Project path (default: current directory)',
|
|
});
|
|
|
|
// Quiet mode
|
|
quiet = Option.Boolean('--quiet,-q', false, {
|
|
description: 'Minimal output',
|
|
});
|
|
|
|
// Explain mode (reasoning-based recommendations)
|
|
explain = Option.Boolean('--explain,-e', false, {
|
|
description: 'Show detailed explanations for recommendations (uses reasoning engine)',
|
|
});
|
|
|
|
// Reasoning mode
|
|
reasoning = Option.Boolean('--reasoning,-r', false, {
|
|
description: 'Use LLM-based reasoning for recommendations',
|
|
});
|
|
|
|
// Show tree path
|
|
showPath = Option.Boolean('--show-path', false, {
|
|
description: 'Show category path for each recommendation',
|
|
});
|
|
|
|
// Hybrid search mode
|
|
hybrid = Option.Boolean('--hybrid,-H', false, {
|
|
description: 'Use hybrid search (vector + keyword)',
|
|
});
|
|
|
|
// Query expansion
|
|
expand = Option.Boolean('--expand,-x', false, {
|
|
description: 'Enable query expansion (requires --hybrid)',
|
|
});
|
|
|
|
// Reranking
|
|
rerank = Option.Boolean('--rerank', false, {
|
|
description: 'Enable LLM reranking (requires --hybrid)',
|
|
});
|
|
|
|
// Build index
|
|
buildIndex = Option.Boolean('--build-index', false, {
|
|
description: 'Build/rebuild the hybrid search embedding index',
|
|
});
|
|
|
|
async execute(): Promise<number> {
|
|
const targetPath = resolve(this.projectPath || process.cwd());
|
|
|
|
// Handle index update
|
|
if (this.update) {
|
|
return await this.updateIndex();
|
|
}
|
|
|
|
// Handle hybrid index building
|
|
if (this.buildIndex) {
|
|
return await this.buildHybridIndex();
|
|
}
|
|
|
|
// Validate hybrid-dependent options
|
|
if ((this.expand || this.rerank) && !this.hybrid) {
|
|
warn('--expand and --rerank require --hybrid flag. These options will be ignored.');
|
|
}
|
|
|
|
if (!this.quiet && !this.json) {
|
|
header('Skill Recommendations');
|
|
}
|
|
|
|
// Load or create project profile
|
|
const profile = await this.getProjectProfile(targetPath);
|
|
if (!profile) {
|
|
console.log(colors.error('Failed to analyze project'));
|
|
return 1;
|
|
}
|
|
|
|
// Load skill index
|
|
const index = this.loadIndex();
|
|
if (!index || index.skills.length === 0) {
|
|
warn('No skill index found.');
|
|
console.log(colors.muted('Run "skillkit recommend --update" to fetch skills from known sources.'));
|
|
console.log(colors.muted('Or install skills manually with "skillkit install <source>"\n'));
|
|
|
|
// Still show project profile
|
|
this.showProjectProfile(profile);
|
|
return 0;
|
|
}
|
|
|
|
// Use reasoning engine if explain/reasoning flags are set
|
|
if (this.explain || this.reasoning || this.showPath) {
|
|
return await this.handleReasoningRecommendations(profile, index);
|
|
}
|
|
|
|
// Create recommendation engine
|
|
const engine = new RecommendationEngine();
|
|
engine.loadIndex(index);
|
|
|
|
// Handle search mode (--search or --task)
|
|
const searchQuery = this.search || this.task;
|
|
if (searchQuery) {
|
|
if (this.hybrid) {
|
|
return await this.handleHybridSearch(engine, searchQuery);
|
|
}
|
|
return this.handleSearch(engine, searchQuery);
|
|
}
|
|
|
|
// Get recommendations
|
|
const result = engine.recommend(profile, {
|
|
limit: this.limit ? parseInt(this.limit, 10) : 10,
|
|
minScore: this.minScore ? parseInt(this.minScore, 10) : 30,
|
|
categories: this.category,
|
|
excludeInstalled: !this.includeInstalled,
|
|
includeReasons: this.verbose,
|
|
});
|
|
|
|
// Output results
|
|
if (this.json) {
|
|
console.log(JSON.stringify(result, null, 2));
|
|
return 0;
|
|
}
|
|
|
|
this.displayRecommendations(result.recommendations, profile, result.totalSkillsScanned);
|
|
return 0;
|
|
}
|
|
|
|
private async handleReasoningRecommendations(
|
|
profile: ProjectProfile,
|
|
index: { skills: ScoredSkill['skill'][]; sources: { name: string; url: string; lastFetched: string; skillCount: number }[]; version: number; lastUpdated: string }
|
|
): Promise<number> {
|
|
const s = !this.quiet && !this.json ? spinner() : null;
|
|
s?.start('Analyzing with reasoning engine...');
|
|
|
|
try {
|
|
const engine = new ReasoningRecommendationEngine();
|
|
engine.loadIndex(index);
|
|
await engine.initReasoning();
|
|
|
|
const result = await engine.recommendWithReasoning(profile, {
|
|
limit: this.limit ? parseInt(this.limit, 10) : 10,
|
|
minScore: this.minScore ? parseInt(this.minScore, 10) : 30,
|
|
categories: this.category,
|
|
excludeInstalled: !this.includeInstalled,
|
|
includeReasons: this.verbose,
|
|
reasoning: this.reasoning,
|
|
explainResults: this.explain,
|
|
useTree: true,
|
|
});
|
|
|
|
s?.stop('Analysis complete');
|
|
|
|
if (this.json) {
|
|
console.log(JSON.stringify(result, null, 2));
|
|
return 0;
|
|
}
|
|
|
|
this.displayExplainedRecommendations(
|
|
result.recommendations,
|
|
profile,
|
|
result.totalSkillsScanned,
|
|
result.reasoningSummary
|
|
);
|
|
return 0;
|
|
} catch (err) {
|
|
s?.stop(colors.error('Reasoning analysis failed'));
|
|
console.log(colors.muted(err instanceof Error ? err.message : String(err)));
|
|
console.log(colors.muted('Falling back to standard recommendations...'));
|
|
console.log('');
|
|
|
|
const engine = new RecommendationEngine();
|
|
engine.loadIndex(index);
|
|
const result = engine.recommend(profile, {
|
|
limit: this.limit ? parseInt(this.limit, 10) : 10,
|
|
minScore: this.minScore ? parseInt(this.minScore, 10) : 30,
|
|
categories: this.category,
|
|
excludeInstalled: !this.includeInstalled,
|
|
includeReasons: this.verbose,
|
|
});
|
|
this.displayRecommendations(result.recommendations, profile, result.totalSkillsScanned);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private async getProjectProfile(projectPath: string): Promise<ProjectProfile | null> {
|
|
const manager = new ContextManager(projectPath);
|
|
let context = manager.get();
|
|
|
|
if (!context) {
|
|
// Auto-analyze project
|
|
if (!this.json && !this.quiet) {
|
|
const s = spinner();
|
|
s.start('Analyzing project...');
|
|
context = manager.init();
|
|
s.stop('Project analyzed');
|
|
} else {
|
|
context = manager.init();
|
|
}
|
|
}
|
|
|
|
if (!context) {
|
|
return null;
|
|
}
|
|
|
|
// Convert ProjectContext to ProjectProfile
|
|
return {
|
|
name: context.project.name,
|
|
type: context.project.type,
|
|
stack: context.stack,
|
|
patterns: context.patterns,
|
|
installedSkills: context.skills?.installed || [],
|
|
excludedSkills: context.skills?.excluded || [],
|
|
};
|
|
}
|
|
|
|
private showProjectProfile(profile: ProjectProfile): void {
|
|
const languages = profile.stack.languages.map(l => `${l.name}${l.version ? ` ${l.version}` : ''}`);
|
|
const frameworks = profile.stack.frameworks.map(f => `${f.name}${f.version ? ` ${f.version}` : ''}`);
|
|
|
|
showProjectSummary({
|
|
name: profile.name,
|
|
type: profile.type,
|
|
languages,
|
|
frameworks,
|
|
});
|
|
}
|
|
|
|
private displayRecommendations(
|
|
recommendations: ScoredSkill[],
|
|
profile: ProjectProfile,
|
|
totalScanned: number
|
|
): void {
|
|
// Show project profile
|
|
this.showProjectProfile(profile);
|
|
|
|
if (recommendations.length === 0) {
|
|
warn('No matching skills found.');
|
|
console.log(colors.muted('Try lowering the minimum score with --min-score'));
|
|
return;
|
|
}
|
|
|
|
console.log(colors.bold(`Recommended Skills (${recommendations.length} of ${totalScanned} scanned):`));
|
|
console.log('');
|
|
|
|
for (const rec of recommendations) {
|
|
let scoreColor: (text: string) => string;
|
|
if (rec.score >= 70) {
|
|
scoreColor = colors.success;
|
|
} else if (rec.score >= 50) {
|
|
scoreColor = colors.warning;
|
|
} else {
|
|
scoreColor = colors.muted;
|
|
}
|
|
const scoreBar = progressBar(rec.score, 100, 10);
|
|
const qualityScore = rec.skill.quality ?? null;
|
|
const qualityDisplay = qualityScore !== null && qualityScore !== undefined
|
|
? ` ${formatQualityBadge(qualityScore)}`
|
|
: '';
|
|
|
|
console.log(` ${scoreColor(`${rec.score}%`)} ${colors.dim(scoreBar)} ${colors.bold(rec.skill.name)}${qualityDisplay}`);
|
|
|
|
if (rec.skill.description) {
|
|
console.log(` ${colors.muted(truncate(rec.skill.description, 70))}`);
|
|
}
|
|
|
|
if (rec.skill.source) {
|
|
console.log(` ${colors.dim('Source:')} ${rec.skill.source}`);
|
|
}
|
|
|
|
if (this.verbose && rec.reasons.length > 0) {
|
|
console.log(colors.dim(' Reasons:'));
|
|
for (const reason of rec.reasons.filter(r => r.weight > 0)) {
|
|
console.log(` ${colors.muted(symbols.stepActive)} ${reason.description} (+${reason.weight})`);
|
|
}
|
|
if (qualityScore !== null && qualityScore !== undefined) {
|
|
const grade = getQualityGradeFromScore(qualityScore);
|
|
console.log(` ${colors.muted(symbols.stepActive)} Quality: ${qualityScore}/100 (${grade})`);
|
|
}
|
|
}
|
|
|
|
if (rec.warnings.length > 0) {
|
|
for (const warning of rec.warnings) {
|
|
console.log(` ${colors.warning(symbols.warning)} ${warning}`);
|
|
}
|
|
}
|
|
|
|
console.log('');
|
|
}
|
|
|
|
console.log(colors.muted('Install with: skillkit install <source>'));
|
|
}
|
|
|
|
private displayExplainedRecommendations(
|
|
recommendations: ExplainedScoredSkill[],
|
|
profile: ProjectProfile,
|
|
totalScanned: number,
|
|
reasoningSummary?: string
|
|
): void {
|
|
this.showProjectProfile(profile);
|
|
|
|
if (reasoningSummary && !this.quiet) {
|
|
console.log(colors.dim('Reasoning: ') + colors.muted(reasoningSummary));
|
|
console.log('');
|
|
}
|
|
|
|
if (recommendations.length === 0) {
|
|
warn('No matching skills found.');
|
|
console.log(colors.muted('Try lowering the minimum score with --min-score'));
|
|
return;
|
|
}
|
|
|
|
console.log(colors.bold(`Explained Recommendations (${recommendations.length} of ${totalScanned} scanned):`));
|
|
console.log('');
|
|
|
|
for (const rec of recommendations) {
|
|
let scoreColor: (text: string) => string;
|
|
if (rec.score >= 70) {
|
|
scoreColor = colors.success;
|
|
} else if (rec.score >= 50) {
|
|
scoreColor = colors.warning;
|
|
} else {
|
|
scoreColor = colors.muted;
|
|
}
|
|
const scoreBar = progressBar(rec.score, 100, 10);
|
|
const qualityScore = rec.skill.quality ?? null;
|
|
const qualityDisplay = qualityScore !== null && qualityScore !== undefined
|
|
? ` ${formatQualityBadge(qualityScore)}`
|
|
: '';
|
|
|
|
console.log(` ${scoreColor(`${rec.score}%`)} ${colors.dim(scoreBar)} ${colors.bold(rec.skill.name)}${qualityDisplay}`);
|
|
|
|
if (this.showPath && rec.treePath && rec.treePath.length > 0) {
|
|
console.log(` ${colors.accent('Path:')} ${rec.treePath.join(' > ')}`);
|
|
}
|
|
|
|
if (rec.skill.description) {
|
|
console.log(` ${colors.muted(truncate(rec.skill.description, 70))}`);
|
|
}
|
|
|
|
if (rec.skill.source) {
|
|
console.log(` ${colors.dim('Source:')} ${rec.skill.source}`);
|
|
}
|
|
|
|
if (this.explain && rec.explanation) {
|
|
console.log(colors.dim(' Why this skill:'));
|
|
if (rec.explanation.matchedBecause.length > 0) {
|
|
console.log(` ${colors.success('├─')} Matched: ${rec.explanation.matchedBecause.join(', ')}`);
|
|
}
|
|
if (rec.explanation.relevantFor.length > 0) {
|
|
console.log(` ${colors.accent('├─')} Relevant for: ${rec.explanation.relevantFor.join(', ')}`);
|
|
}
|
|
if (rec.explanation.confidence) {
|
|
const confidenceColor = rec.explanation.confidence === 'high' ? colors.success :
|
|
rec.explanation.confidence === 'medium' ? colors.warning :
|
|
colors.muted;
|
|
console.log(` ${colors.dim('└─')} Confidence: ${confidenceColor(rec.explanation.confidence)}`);
|
|
}
|
|
}
|
|
|
|
if (this.verbose && rec.reasons.length > 0) {
|
|
console.log(colors.dim(' Score breakdown:'));
|
|
for (const reason of rec.reasons.filter(r => r.weight > 0)) {
|
|
console.log(` ${colors.muted(symbols.stepActive)} ${reason.description} (+${reason.weight})`);
|
|
}
|
|
if (qualityScore !== null && qualityScore !== undefined) {
|
|
const grade = getQualityGradeFromScore(qualityScore);
|
|
console.log(` ${colors.muted(symbols.stepActive)} Quality: ${qualityScore}/100 (${grade})`);
|
|
}
|
|
}
|
|
|
|
if (rec.warnings.length > 0) {
|
|
for (const warning of rec.warnings) {
|
|
console.log(` ${colors.warning(symbols.warning)} ${warning}`);
|
|
}
|
|
}
|
|
|
|
console.log('');
|
|
}
|
|
|
|
console.log(colors.muted('Install with: skillkit install <source>'));
|
|
console.log(colors.muted('More details: skillkit recommend --explain --verbose'));
|
|
}
|
|
|
|
private async handleHybridSearch(engine: RecommendationEngine, query: string): Promise<number> {
|
|
if (!this.quiet && !this.json) {
|
|
header(`Hybrid Search: "${query}"`);
|
|
}
|
|
|
|
const s = !this.quiet && !this.json ? spinner() : null;
|
|
s?.start('Initializing hybrid search...');
|
|
|
|
try {
|
|
await engine.initHybridSearch();
|
|
s?.message('Searching...');
|
|
|
|
const results = await engine.hybridSearch({
|
|
query,
|
|
limit: this.limit ? parseInt(this.limit, 10) : 10,
|
|
hybrid: true,
|
|
enableExpansion: this.expand,
|
|
enableReranking: this.rerank,
|
|
filters: {
|
|
minScore: this.minScore ? parseInt(this.minScore, 10) : undefined,
|
|
},
|
|
});
|
|
|
|
s?.stop(`Found ${results.length} results`);
|
|
|
|
if (this.json) {
|
|
console.log(JSON.stringify(results, null, 2));
|
|
return 0;
|
|
}
|
|
|
|
if (results.length === 0) {
|
|
warn(`No skills found matching "${query}"`);
|
|
return 0;
|
|
}
|
|
|
|
console.log('');
|
|
console.log(colors.bold(`Hybrid search results for "${query}" (${results.length} found):`));
|
|
if (this.expand && results[0]?.expandedTerms?.length) {
|
|
console.log(colors.muted(` Expanded: ${results[0].expandedTerms.join(', ')}`));
|
|
}
|
|
console.log('');
|
|
|
|
for (const result of results) {
|
|
let relevanceColor: (text: string) => string;
|
|
if (result.relevance >= 70) {
|
|
relevanceColor = colors.success;
|
|
} else if (result.relevance >= 50) {
|
|
relevanceColor = colors.warning;
|
|
} else {
|
|
relevanceColor = colors.muted;
|
|
}
|
|
const relevanceBar = progressBar(result.relevance, 100, 10);
|
|
|
|
console.log(` ${relevanceColor(`${result.relevance}%`)} ${colors.dim(relevanceBar)} ${colors.bold(result.skill.name)}`);
|
|
|
|
if (result.skill.description) {
|
|
console.log(` ${colors.muted(truncate(result.skill.description, 70))}`);
|
|
}
|
|
|
|
if (this.verbose) {
|
|
const scores: string[] = [];
|
|
if (typeof result.vectorSimilarity === 'number') {
|
|
scores.push(`vector: ${(result.vectorSimilarity * 100).toFixed(0)}%`);
|
|
}
|
|
if (typeof result.keywordScore === 'number') {
|
|
scores.push(`keyword: ${result.keywordScore.toFixed(0)}%`);
|
|
}
|
|
if (typeof result.rrfScore === 'number') {
|
|
scores.push(`rrf: ${result.rrfScore.toFixed(3)}`);
|
|
}
|
|
if (scores.length > 0) {
|
|
console.log(` ${colors.dim('Scores:')} ${scores.join(' | ')}`);
|
|
}
|
|
}
|
|
|
|
if (result.matchedTerms.length > 0) {
|
|
console.log(` ${colors.dim('Matched:')} ${result.matchedTerms.join(', ')}`);
|
|
}
|
|
|
|
console.log('');
|
|
}
|
|
|
|
return 0;
|
|
} catch (err) {
|
|
s?.stop(colors.error('Hybrid search failed'));
|
|
console.log(colors.muted(err instanceof Error ? err.message : String(err)));
|
|
console.log(colors.muted('Falling back to standard search...'));
|
|
return this.handleSearch(engine, query);
|
|
}
|
|
}
|
|
|
|
private async buildHybridIndex(): Promise<number> {
|
|
if (!this.quiet) {
|
|
header('Build Hybrid Search Index');
|
|
}
|
|
|
|
const index = this.loadIndex();
|
|
if (!index || index.skills.length === 0) {
|
|
warn('No skill index found. Run --update first.');
|
|
return 1;
|
|
}
|
|
|
|
const s = spinner();
|
|
s.start('Initializing...');
|
|
|
|
try {
|
|
const engine = new RecommendationEngine();
|
|
engine.loadIndex(index);
|
|
|
|
await engine.buildHybridIndex((progress) => {
|
|
const percentage = Math.round((progress.current / progress.total) * 100);
|
|
s.message(`${progress.phase}: ${progress.message || ''} (${percentage}%)`);
|
|
});
|
|
|
|
s.stop(colors.success(`${symbols.success} Built hybrid index for ${index.skills.length} skills`));
|
|
console.log(colors.muted(' Index stored in: ~/.skillkit/search.db'));
|
|
console.log(colors.muted(' Use --hybrid flag for vector+keyword search\n'));
|
|
|
|
return 0;
|
|
} catch (err) {
|
|
s.stop(colors.error('Failed to build hybrid index'));
|
|
console.log(colors.muted(err instanceof Error ? err.message : String(err)));
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
private handleSearch(engine: RecommendationEngine, query: string): number {
|
|
if (!this.quiet && !this.json) {
|
|
header(`Search: "${query}"`);
|
|
}
|
|
|
|
const results = engine.search({
|
|
query,
|
|
limit: this.limit ? parseInt(this.limit, 10) : 10,
|
|
semantic: true,
|
|
filters: {
|
|
minScore: this.minScore ? parseInt(this.minScore, 10) : undefined,
|
|
},
|
|
});
|
|
|
|
if (this.json) {
|
|
console.log(JSON.stringify(results, null, 2));
|
|
return 0;
|
|
}
|
|
|
|
if (results.length === 0) {
|
|
warn(`No skills found matching "${query}"`);
|
|
return 0;
|
|
}
|
|
|
|
console.log('');
|
|
console.log(colors.bold(`Search results for "${query}" (${results.length} found):`));
|
|
console.log('');
|
|
|
|
for (const result of results) {
|
|
let relevanceColor: (text: string) => string;
|
|
if (result.relevance >= 70) {
|
|
relevanceColor = colors.success;
|
|
} else if (result.relevance >= 50) {
|
|
relevanceColor = colors.warning;
|
|
} else {
|
|
relevanceColor = colors.muted;
|
|
}
|
|
const relevanceBar = progressBar(result.relevance, 100, 10);
|
|
|
|
console.log(` ${relevanceColor(`${result.relevance}%`)} ${colors.dim(relevanceBar)} ${colors.bold(result.skill.name)}`);
|
|
|
|
if (result.snippet) {
|
|
console.log(` ${colors.muted(result.snippet)}`);
|
|
}
|
|
|
|
if (result.matchedTerms.length > 0) {
|
|
console.log(` ${colors.dim('Matched:')} ${result.matchedTerms.join(', ')}`);
|
|
}
|
|
|
|
console.log('');
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private loadIndex() {
|
|
const index = loadIndexFromCache();
|
|
|
|
if (!index) {
|
|
return null;
|
|
}
|
|
|
|
// Check if index is stale
|
|
if (isIndexStale(index) && !this.json && !this.quiet) {
|
|
const lastUpdated = new Date(index.lastUpdated);
|
|
const hoursSinceUpdate = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60);
|
|
console.log(
|
|
colors.muted(`Index is ${Math.round(hoursSinceUpdate)} hours old. Run --update to refresh.\n`)
|
|
);
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
private async updateIndex(): Promise<number> {
|
|
if (!this.quiet) {
|
|
header('Update Skill Index');
|
|
}
|
|
|
|
console.log(colors.muted(`Sources: ${KNOWN_SKILL_REPOS.map(r => `${r.owner}/${r.repo}`).join(', ')}\n`));
|
|
|
|
const s = spinner();
|
|
s.start('Fetching skills...');
|
|
|
|
try {
|
|
const { index, errors } = await buildSkillIndex(KNOWN_SKILL_REPOS, (message) => {
|
|
s.message(message);
|
|
});
|
|
|
|
s.stop(`Fetched ${index.skills.length} skills`);
|
|
|
|
// Report any errors
|
|
if (errors.length > 0) {
|
|
console.log('');
|
|
console.log(colors.warning('Warnings:'));
|
|
for (const error of errors) {
|
|
console.log(colors.muted(` ${symbols.stepActive} ${error}`));
|
|
}
|
|
}
|
|
|
|
// Save the index
|
|
saveIndex(index);
|
|
|
|
console.log('');
|
|
console.log(colors.success(`${symbols.success} Updated index with ${index.skills.length} skills`));
|
|
if (index.sources.length > 0) {
|
|
console.log(colors.muted(` Sources: ${index.sources.map((s) => s.name).join(', ')}`));
|
|
}
|
|
console.log(colors.muted(` Saved to: ${INDEX_PATH}\n`));
|
|
|
|
return 0;
|
|
} catch (err) {
|
|
s.stop(colors.error('Failed to update index'));
|
|
console.log(colors.muted(err instanceof Error ? err.message : String(err)));
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
function truncate(str: string, maxLen: number): string {
|
|
if (str.length <= maxLen) return str;
|
|
return str.slice(0, maxLen - 3) + '...';
|
|
}
|