claude-flow-novice 2.18.2 → 2.18.3

package/dist/ruvector/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * CFN RuVector CLI - Semantic codebase search
+ */ import { Command } from 'commander';
+import { RuVectorIndex } from './core/index.js';
+const program = new Command();
+program.name('cfn-ruvector').description('Semantic codebase search using vector embeddings').version('1.0.0');
+program.command('index').description('Index the codebase').argument('[directory]', 'Directory to index', '.').option('-v, --verbose', 'Verbose output').action(async (directory, options)=>{
+    try {
+        const index = new RuVectorIndex({
+            verbose: options.verbose
+        });
+        console.log(`Indexing ${directory}...`);
+        const stats = await index.indexDirectory(directory);
+        console.log(`\nDone: ${stats.indexedFiles}/${stats.totalFiles} indexed, ${stats.failedFiles} failed`);
+    } catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
+});
+program.command('search').description('Search the codebase').argument('<query>', 'Search query').option('-n, --limit <n>', 'Number of results', '10').action(async (query, options)=>{
+    try {
+        const index = new RuVectorIndex();
+        const limit = parseInt(options.limit ?? '10', 10);
+        const results = await index.search(query, {
+            limit
+        });
+        if (results.length === 0) {
+            console.log('No results found.');
+            return;
+        }
+        console.log(`\nResults for: "${query}"\n`);
+        for (const r of results){
+            console.log(`[${(r.score * 100).toFixed(1)}%]  ${r.path}`);
+        }
+    } catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
+});
+program.command('status').description('Show index stats').action(async ()=>{
+    try {
+        const index = new RuVectorIndex();
+        const stats = await index.getStats();
+        console.log(`Indexed files: ${stats.indexedFiles}`);
+    } catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
+});
+program.command('clear').description('Clear the index').option('-f, --force', 'Force clear').action(async (options)=>{
+    if (!options.force) {
+        console.log('Use --force to confirm.');
+        process.exit(1);
+    }
+    const index = new RuVectorIndex();
+    await index.clear();
+    console.log('Index cleared.');
+});
+program.parse();
+
+//# sourceMappingURL=cli.js.map

package/dist/ruvector/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ruvector/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * CFN RuVector CLI - Semantic codebase search\n */\n\nimport { Command } from 'commander';\nimport { RuVectorIndex } from './core/index.js';\n\nconst program = new Command();\n\nprogram\n  .name('cfn-ruvector')\n  .description('Semantic codebase search using vector embeddings')\n  .version('1.0.0');\n\nprogram\n  .command('index')\n  .description('Index the codebase')\n  .argument('[directory]', 'Directory to index', '.')\n  .option('-v, --verbose', 'Verbose output')\n  .action(async (directory: string, options: { verbose?: boolean }) => {\n    try {\n      const index = new RuVectorIndex({ verbose: options.verbose });\n      console.log(`Indexing ${directory}...`);\n      const stats = await index.indexDirectory(directory);\n      console.log(`\\nDone: ${stats.indexedFiles}/${stats.totalFiles} indexed, ${stats.failedFiles} failed`);\n    } catch (error) {\n      console.error('Error:', (error as Error).message);\n      process.exit(1);\n    }\n  });\n\nprogram\n  .command('search')\n  .description('Search the codebase')\n  .argument('<query>', 'Search query')\n  .option('-n, --limit <n>', 'Number of results', '10')\n  .action(async (query: string, options: { limit?: string }) => {\n    try {\n      const index = new RuVectorIndex();\n      const limit = parseInt(options.limit ?? '10', 10);\n      const results = await index.search(query, { limit });\n      \n      if (results.length === 0) {\n        console.log('No results found.');\n        return;\n      }\n      \n      console.log(`\\nResults for: \"${query}\"\\n`);\n      for (const r of results) {\n        console.log(`[${(r.score * 100).toFixed(1)}%]  ${r.path}`);\n      }\n    } catch (error) {\n      console.error('Error:', (error as Error).message);\n      process.exit(1);\n    }\n  });\n\nprogram\n  .command('status')\n  .description('Show index stats')\n  .action(async () => {\n    try {\n      const index = new RuVectorIndex();\n      const stats = await index.getStats();\n      console.log(`Indexed files: ${stats.indexedFiles}`);\n    } catch (error) {\n      console.error('Error:', (error as Error).message);\n      process.exit(1);\n    }\n  });\n\nprogram\n  .command('clear')\n  .description('Clear the index')\n  .option('-f, --force', 'Force clear')\n  .action(async (options: { force?: boolean }) => {\n    if (!options.force) {\n      console.log('Use --force to confirm.');\n      process.exit(1);\n    }\n    const index = new RuVectorIndex();\n    await index.clear();\n    console.log('Index cleared.');\n  });\n\nprogram.parse();"],"names":["Command","RuVectorIndex","program","name","description","version","command","argument","option","action","directory","options","index","verbose","console","log","stats","indexDirectory","indexedFiles","totalFiles","failedFiles","error","message","process","exit","query","limit","parseInt","results","search","length","r","score","toFixed","path","getStats","force","clear","parse"],"mappings":";AACA;;CAEC,GAED,SAASA,OAAO,QAAQ,YAAY;AACpC,SAASC,aAAa,QAAQ,kBAAkB;AAEhD,MAAMC,UAAU,IAAIF;AAEpBE,QACGC,IAAI,CAAC,gBACLC,WAAW,CAAC,oDACZC,OAAO,CAAC;AAEXH,QACGI,OAAO,CAAC,SACRF,WAAW,CAAC,sBACZG,QAAQ,CAAC,eAAe,sBAAsB,KAC9CC,MAAM,CAAC,iBAAiB,kBACxBC,MAAM,CAAC,OAAOC,WAAmBC;IAChC,IAAI;QACF,MAAMC,QAAQ,IAAIX,cAAc;YAAEY,SAASF,QAAQE,OAAO;QAAC;QAC3DC,QAAQC,GAAG,CAAC,CAAC,SAAS,EAAEL,UAAU,GAAG,CAAC;QACtC,MAAMM,QAAQ,MAAMJ,MAAMK,cAAc,CAACP;QACzCI,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEC,MAAME,YAAY,CAAC,CAAC,EAAEF,MAAMG,UAAU,CAAC,UAAU,EAAEH,MAAMI,WAAW,CAAC,OAAO,CAAC;IACtG,EAAE,OAAOC,OAAO;QACdP,QAAQO,KAAK,CAAC,UAAU,AAACA,MAAgBC,OAAO;QAChDC,QAAQC,IAAI,CAAC;IACf;AACF;AAEFtB,QACGI,OAAO,CAAC,UACRF,WAAW,CAAC,uBACZG,QAAQ,CAAC,WAAW,gBACpBC,MAAM,CAAC,mBAAmB,qBAAqB,MAC/CC,MAAM,CAAC,OAAOgB,OAAed;IAC5B,IAAI;QACF,MAAMC,QAAQ,IAAIX;QAClB,MAAMyB,QAAQC,SAAShB,QAAQe,KAAK,IAAI,MAAM;QAC9C,MAAME,UAAU,MAAMhB,MAAMiB,MAAM,CAACJ,OAAO;YAAEC;QAAM;QAElD,IAAIE,QAAQE,MAAM,KAAK,GAAG;YACxBhB,QAAQC,GAAG,CAAC;YACZ;QACF;QAEAD,QAAQC,GAAG,CAAC,CAAC,gBAAgB,EAAEU,MAAM,GAAG,CAAC;QACzC,KAAK,MAAMM,KAAKH,QAAS;YACvBd,QAAQC,GAAG,CAAC,CAAC,CAAC,EAAE,AAACgB,CAAAA,EAAEC,KAAK,GAAG,GAAE,EAAGC,OAAO,CAAC,GAAG,IAAI,EAAEF,EAAEG,IAAI,EAAE;QAC3D;IACF,EAAE,OAAOb,OAAO;QACdP,QAAQO,KAAK,CAAC,UAAU,AAACA,MAAgBC,OAAO;QAChDC,QAAQC,IAAI,CAAC;IACf;AACF;AAEFtB,QACGI,OAAO,CAAC,UACRF,WAAW,CAAC,oBACZK,MAAM,CAAC;IACN,IAAI;QACF,MAAMG,QAAQ,IAAIX;QAClB,MAAMe,QAAQ,MAAMJ,MAAMuB,QAAQ;QAClCrB,QAAQC,GAAG,CAAC,CAAC,eAAe,EAAEC,MAAME,YAAY,EAAE;IACpD,EAAE,OAAOG,OAAO;QACdP,QAAQO,KAAK,CAAC,UAAU,AAACA,MAAgBC,OAAO;QAChDC,QAAQC,IAAI,CAAC;IACf;AACF;AAEFtB,QACGI,OAAO,CAAC,SACRF,WAAW,CAAC,mBACZI,MAAM,CAAC,eAAe,eACtBC,MAAM,CAAC,OAAOE;IACb,IAAI,CAACA,QAAQyB,KAAK,EAAE;QAClBtB,QAAQC,GAAG,CAAC;QACZQ,QAAQC,IAAI,CAAC;IACf;IACA,MAAMZ,QAAQ,IAAIX;IAClB,MAAMW,MAAMyB,KAAK;IACjBvB,QAAQC,GAAG,CAAC;AACd;AAEFb,QAAQoC,KAAK"}

package/dist/ruvector/core/file-processor.js

@@ -0,0 +1,72 @@
+/**
+ * File Processor - Extracts indexable text from source files
+ */ import * as fs from 'fs/promises';
+import * as path from 'path';
+const LANGUAGE_MAP = {
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.mjs': 'javascript',
+    '.py': 'python',
+    '.rb': 'ruby',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.java': 'java',
+    '.kt': 'kotlin',
+    '.swift': 'swift',
+    '.c': 'c',
+    '.cpp': 'cpp',
+    '.h': 'c',
+    '.hpp': 'cpp',
+    '.cs': 'csharp',
+    '.php': 'php',
+    '.md': 'markdown',
+    '.mdx': 'markdown',
+    '.json': 'json',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.html': 'html',
+    '.css': 'css',
+    '.scss': 'scss',
+    '.sql': 'sql',
+    '.sh': 'shell',
+    '.bash': 'shell'
+};
+export class SourceFileProcessor {
+    maxFileSize;
+    constructor(maxFileSize = 100 * 1024){
+        this.maxFileSize = maxFileSize;
+    }
+    canProcess(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        return ext in LANGUAGE_MAP;
+    }
+    async process(filePath) {
+        try {
+            const stats = await fs.stat(filePath);
+            if (stats.size > this.maxFileSize || !stats.isFile()) return null;
+            const content = await fs.readFile(filePath, 'utf-8');
+            const ext = path.extname(filePath).toLowerCase();
+            const language = LANGUAGE_MAP[ext] ?? 'unknown';
+            let processed = content.replace(/\n{3,}/g, '\n\n');
+            const maxChars = 8000;
+            if (processed.length > maxChars) {
+                processed = processed.slice(0, maxChars) + '\n[truncated]';
+            }
+            return {
+                path: filePath,
+                content: processed.trim(),
+                language,
+                size: stats.size
+            };
+        } catch  {
+            return null;
+        }
+    }
+}
+export function createFileProcessor(maxFileSize) {
+    return new SourceFileProcessor(maxFileSize);
+}
+
+//# sourceMappingURL=file-processor.js.map

package/dist/ruvector/core/file-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ruvector/core/file-processor.ts"],"sourcesContent":["/**\n * File Processor - Extracts indexable text from source files\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\nexport interface ProcessedFile {\n  path: string;\n  content: string;\n  language: string;\n  size: number;\n}\n\nexport interface FileProcessor {\n  process(filePath: string): Promise<ProcessedFile | null>;\n  canProcess(filePath: string): boolean;\n}\n\nconst LANGUAGE_MAP: Record<string, string> = {\n  '.ts': 'typescript', '.tsx': 'typescript',\n  '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript',\n  '.py': 'python', '.rb': 'ruby', '.go': 'go', '.rs': 'rust',\n  '.java': 'java', '.kt': 'kotlin', '.swift': 'swift',\n  '.c': 'c', '.cpp': 'cpp', '.h': 'c', '.hpp': 'cpp',\n  '.cs': 'csharp', '.php': 'php',\n  '.md': 'markdown', '.mdx': 'markdown',\n  '.json': 'json', '.yaml': 'yaml', '.yml': 'yaml',\n  '.html': 'html', '.css': 'css', '.scss': 'scss',\n  '.sql': 'sql', '.sh': 'shell', '.bash': 'shell',\n};\n\nexport class SourceFileProcessor implements FileProcessor {\n  private maxFileSize: number;\n  \n  constructor(maxFileSize: number = 100 * 1024) {\n    this.maxFileSize = maxFileSize;\n  }\n  \n  canProcess(filePath: string): boolean {\n    const ext = path.extname(filePath).toLowerCase();\n    return ext in LANGUAGE_MAP;\n  }\n  \n  async process(filePath: string): Promise<ProcessedFile | null> {\n    try {\n      const stats = await fs.stat(filePath);\n      if (stats.size > this.maxFileSize || !stats.isFile()) return null;\n      \n      const content = await fs.readFile(filePath, 'utf-8');\n      const ext = path.extname(filePath).toLowerCase();\n      const language = LANGUAGE_MAP[ext] ?? 'unknown';\n      \n      let processed = content.replace(/\\n{3,}/g, '\\n\\n');\n      const maxChars = 8000;\n      if (processed.length > maxChars) {\n        processed = processed.slice(0, maxChars) + '\\n[truncated]';\n      }\n      \n      return { path: filePath, content: processed.trim(), language, size: stats.size };\n    } catch {\n      return null;\n    }\n  }\n}\n\nexport function createFileProcessor(maxFileSize?: number): FileProcessor {\n  return new SourceFileProcessor(maxFileSize);\n}"],"names":["fs","path","LANGUAGE_MAP","SourceFileProcessor","maxFileSize","canProcess","filePath","ext","extname","toLowerCase","process","stats","stat","size","isFile","content","readFile","language","processed","replace","maxChars","length","slice","trim","createFileProcessor"],"mappings":"AAAA;;CAEC,GAED,YAAYA,QAAQ,cAAc;AAClC,YAAYC,UAAU,OAAO;AAc7B,MAAMC,eAAuC;IAC3C,OAAO;IAAc,QAAQ;IAC7B,OAAO;IAAc,QAAQ;IAAc,QAAQ;IACnD,OAAO;IAAU,OAAO;IAAQ,OAAO;IAAM,OAAO;IACpD,SAAS;IAAQ,OAAO;IAAU,UAAU;IAC5C,MAAM;IAAK,QAAQ;IAAO,MAAM;IAAK,QAAQ;IAC7C,OAAO;IAAU,QAAQ;IACzB,OAAO;IAAY,QAAQ;IAC3B,SAAS;IAAQ,SAAS;IAAQ,QAAQ;IAC1C,SAAS;IAAQ,QAAQ;IAAO,SAAS;IACzC,QAAQ;IAAO,OAAO;IAAS,SAAS;AAC1C;AAEA,OAAO,MAAMC;IACHC,YAAoB;IAE5B,YAAYA,cAAsB,MAAM,IAAI,CAAE;QAC5C,IAAI,CAACA,WAAW,GAAGA;IACrB;IAEAC,WAAWC,QAAgB,EAAW;QACpC,MAAMC,MAAMN,KAAKO,OAAO,CAACF,UAAUG,WAAW;QAC9C,OAAOF,OAAOL;IAChB;IAEA,MAAMQ,QAAQJ,QAAgB,EAAiC;QAC7D,IAAI;YACF,MAAMK,QAAQ,MAAMX,GAAGY,IAAI,CAACN;YAC5B,IAAIK,MAAME,IAAI,GAAG,IAAI,CAACT,WAAW,IAAI,CAACO,MAAMG,MAAM,IAAI,OAAO;YAE7D,MAAMC,UAAU,MAAMf,GAAGgB,QAAQ,CAACV,UAAU;YAC5C,MAAMC,MAAMN,KAAKO,OAAO,CAACF,UAAUG,WAAW;YAC9C,MAAMQ,WAAWf,YAAY,CAACK,IAAI,IAAI;YAEtC,IAAIW,YAAYH,QAAQI,OAAO,CAAC,WAAW;YAC3C,MAAMC,WAAW;YACjB,IAAIF,UAAUG,MAAM,GAAGD,UAAU;gBAC/BF,YAAYA,UAAUI,KAAK,CAAC,GAAGF,YAAY;YAC7C;YAEA,OAAO;gBAAEnB,MAAMK;gBAAUS,SAASG,UAAUK,IAAI;gBAAIN;gBAAUJ,MAAMF,MAAME,IAAI;YAAC;QACjF,EAAE,OAAM;YACN,OAAO;QACT;IACF;AACF;AAEA,OAAO,SAASW,oBAAoBpB,WAAoB;IACtD,OAAO,IAAID,oBAAoBC;AACjC"}

package/dist/ruvector/core/index.js

@@ -0,0 +1,133 @@
+/**
+ * RuVectorIndex - Core API for semantic codebase search
+ */ import { glob } from 'glob';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { createEmbeddingProvider } from '../embeddings/index.js';
+import { createFileProcessor } from './file-processor.js';
+export class RuVectorIndex {
+    embeddingProvider;
+    fileProcessor;
+    db = null;
+    workingDir;
+    storagePath;
+    include;
+    exclude;
+    batchSize;
+    verbose;
+    constructor(options = {}, workingDir = process.cwd()){
+        this.workingDir = workingDir;
+        this.storagePath = options.storagePath ?? './data/codebase.db';
+        this.include = options.indexing?.include ?? [
+            '**/*.ts',
+            '**/*.js',
+            '**/*.md'
+        ];
+        this.exclude = options.indexing?.exclude ?? [
+            'node_modules/**',
+            'dist/**',
+            '.git/**'
+        ];
+        this.batchSize = options.indexing?.batchSize ?? 50;
+        this.verbose = options.verbose ?? false;
+        this.embeddingProvider = createEmbeddingProvider({
+            provider: options.embedding?.provider ?? 'openai',
+            model: options.embedding?.model,
+            apiKey: options.embedding?.apiKey,
+            baseUrl: options.embedding?.baseUrl
+        });
+        this.fileProcessor = createFileProcessor(options.indexing?.maxFileSize);
+    }
+    async getDb() {
+        if (this.db) return this.db;
+        const { VectorDB } = await import('@ruvector/core');
+        const storagePath = path.resolve(this.workingDir, this.storagePath);
+        await fs.mkdir(path.dirname(storagePath), {
+            recursive: true
+        });
+        this.db = new VectorDB({
+            dimensions: 1536,
+            storagePath
+        });
+        return this.db;
+    }
+    log(msg) {
+        if (this.verbose) console.log(`[ruvector] ${msg}`);
+    }
+    async indexDirectory(directory = '.') {
+        const absoluteDir = path.resolve(this.workingDir, directory);
+        this.log(`Indexing: ${absoluteDir}`);
+        const patterns = this.include.map((p)=>path.join(absoluteDir, p));
+        const files = await glob(patterns, {
+            ignore: this.exclude,
+            nodir: true,
+            absolute: true
+        });
+        this.log(`Found ${files.length} files`);
+        const stats = {
+            totalFiles: files.length,
+            indexedFiles: 0,
+            failedFiles: 0,
+            lastIndexedAt: new Date()
+        };
+        const db = await this.getDb();
+        for(let i = 0; i < files.length; i += this.batchSize){
+            const batch = files.slice(i, i + this.batchSize);
+            const processed = [];
+            for (const file of batch){
+                const result = await this.fileProcessor.process(file);
+                if (result) processed.push(result);
+                else stats.failedFiles++;
+            }
+            if (processed.length === 0) continue;
+            try {
+                const texts = processed.map((p)=>p.content);
+                const embeddings = await this.embeddingProvider.embedBatch(texts);
+                const items = processed.map((p, idx)=>({
+                        id: path.relative(this.workingDir, p.path),
+                        vector: new Float32Array(embeddings[idx].embedding)
+                    }));
+                await db.upsert(items);
+                stats.indexedFiles += processed.length;
+                this.log(`Indexed ${stats.indexedFiles}/${stats.totalFiles}`);
+            } catch (error) {
+                this.log(`Batch failed: ${error.message}`);
+                stats.failedFiles += processed.length;
+            }
+        }
+        return stats;
+    }
+    async search(query, options = {}) {
+        const limit = options.limit ?? 10;
+        const { embedding } = await this.embeddingProvider.embed(query);
+        const db = await this.getDb();
+        const results = await db.search({
+            vector: new Float32Array(embedding),
+            k: limit
+        });
+        return results.map((r)=>({
+                path: r.id,
+                score: r.score
+            }));
+    }
+    async getStats() {
+        const db = await this.getDb();
+        const count = await db.count();
+        return {
+            totalFiles: count,
+            indexedFiles: count,
+            failedFiles: 0,
+            lastIndexedAt: null
+        };
+    }
+    async clear() {
+        const storagePath = path.resolve(this.workingDir, this.storagePath);
+        try {
+            await fs.unlink(storagePath);
+            this.db = null;
+        } catch  {}
+    }
+}
+export { createFileProcessor } from './file-processor.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ruvector/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ruvector/core/index.ts"],"sourcesContent":["/**\n * RuVectorIndex - Core API for semantic codebase search\n */\n\nimport { glob } from 'glob';\nimport * as path from 'path';\nimport * as fs from 'fs/promises';\n\nimport { createEmbeddingProvider, type EmbeddingProvider } from '../embeddings/index.js';\nimport { createFileProcessor, type FileProcessor, type ProcessedFile } from './file-processor.js';\n\nexport interface SearchResult {\n  path: string;\n  score: number;\n}\n\nexport interface IndexStats {\n  totalFiles: number;\n  indexedFiles: number;\n  failedFiles: number;\n  lastIndexedAt: Date | null;\n}\n\nexport interface RuVectorIndexOptions {\n  storagePath?: string;\n  embedding?: {\n    provider?: 'openai' | 'ollama' | 'transformers';\n    model?: string;\n    apiKey?: string;\n    baseUrl?: string;\n  };\n  indexing?: {\n    include?: string[];\n    exclude?: string[];\n    maxFileSize?: number;\n    batchSize?: number;\n  };\n  verbose?: boolean;\n}\n\ninterface VectorDB {\n  upsert(items: Array<{ id: string; vector: Float32Array }>): Promise<void>;\n  search(params: { vector: Float32Array; k: number }): Promise<Array<{ id: string; score: number }>>;\n  count(): Promise<number>;\n}\n\nexport class RuVectorIndex {\n  private embeddingProvider: EmbeddingProvider;\n  private fileProcessor: FileProcessor;\n  private db: VectorDB | null = null;\n  private workingDir: string;\n  private storagePath: string;\n  private include: string[];\n  private exclude: string[];\n  private batchSize: number;\n  private verbose: boolean;\n  \n  constructor(options: RuVectorIndexOptions = {}, workingDir: string = process.cwd()) {\n    this.workingDir = workingDir;\n    this.storagePath = options.storagePath ?? './data/codebase.db';\n    this.include = options.indexing?.include ?? ['**/*.ts', '**/*.js', '**/*.md'];\n    this.exclude = options.indexing?.exclude ?? ['node_modules/**', 'dist/**', '.git/**'];\n    this.batchSize = options.indexing?.batchSize ?? 50;\n    this.verbose = options.verbose ?? false;\n    \n    this.embeddingProvider = createEmbeddingProvider({\n      provider: options.embedding?.provider ?? 'openai',\n      model: options.embedding?.model,\n      apiKey: options.embedding?.apiKey,\n      baseUrl: options.embedding?.baseUrl,\n    });\n    \n    this.fileProcessor = createFileProcessor(options.indexing?.maxFileSize);\n  }\n  \n  private async getDb(): Promise<VectorDB> {\n    if (this.db) return this.db;\n    \n    const { VectorDB } = await import('@ruvector/core');\n    const storagePath = path.resolve(this.workingDir, this.storagePath);\n    await fs.mkdir(path.dirname(storagePath), { recursive: true });\n    \n    this.db = new VectorDB({ dimensions: 1536, storagePath });\n    return this.db;\n  }\n  \n  private log(msg: string): void {\n    if (this.verbose) console.log(`[ruvector] ${msg}`);\n  }\n  \n  async indexDirectory(directory: string = '.'): Promise<IndexStats> {\n    const absoluteDir = path.resolve(this.workingDir, directory);\n    this.log(`Indexing: ${absoluteDir}`);\n    \n    const patterns = this.include.map(p => path.join(absoluteDir, p));\n    const files = await glob(patterns, { ignore: this.exclude, nodir: true, absolute: true });\n    \n    this.log(`Found ${files.length} files`);\n    \n    const stats: IndexStats = { totalFiles: files.length, indexedFiles: 0, failedFiles: 0, lastIndexedAt: new Date() };\n    const db = await this.getDb();\n    \n    for (let i = 0; i < files.length; i += this.batchSize) {\n      const batch = files.slice(i, i + this.batchSize);\n      const processed: ProcessedFile[] = [];\n      \n      for (const file of batch) {\n        const result = await this.fileProcessor.process(file);\n        if (result) processed.push(result);\n        else stats.failedFiles++;\n      }\n      \n      if (processed.length === 0) continue;\n      \n      try {\n        const texts = processed.map(p => p.content);\n        const embeddings = await this.embeddingProvider.embedBatch(texts);\n        \n        const items = processed.map((p, idx) => ({\n          id: path.relative(this.workingDir, p.path),\n          vector: new Float32Array(embeddings[idx].embedding),\n        }));\n        \n        await db.upsert(items);\n        stats.indexedFiles += processed.length;\n        this.log(`Indexed ${stats.indexedFiles}/${stats.totalFiles}`);\n      } catch (error) {\n        this.log(`Batch failed: ${(error as Error).message}`);\n        stats.failedFiles += processed.length;\n      }\n    }\n    \n    return stats;\n  }\n  \n  async search(query: string, options: { limit?: number } = {}): Promise<SearchResult[]> {\n    const limit = options.limit ?? 10;\n    const { embedding } = await this.embeddingProvider.embed(query);\n    const db = await this.getDb();\n    \n    const results = await db.search({ vector: new Float32Array(embedding), k: limit });\n    return results.map(r => ({ path: r.id, score: r.score }));\n  }\n  \n  async getStats(): Promise<IndexStats> {\n    const db = await this.getDb();\n    const count = await db.count();\n    return { totalFiles: count, indexedFiles: count, failedFiles: 0, lastIndexedAt: null };\n  }\n  \n  async clear(): Promise<void> {\n    const storagePath = path.resolve(this.workingDir, this.storagePath);\n    try { await fs.unlink(storagePath); this.db = null; } catch {}\n  }\n}\n\nexport { createFileProcessor, type ProcessedFile, type FileProcessor } from './file-processor.js';"],"names":["glob","path","fs","createEmbeddingProvider","createFileProcessor","RuVectorIndex","embeddingProvider","fileProcessor","db","workingDir","storagePath","include","exclude","batchSize","verbose","options","process","cwd","indexing","provider","embedding","model","apiKey","baseUrl","maxFileSize","getDb","VectorDB","resolve","mkdir","dirname","recursive","dimensions","log","msg","console","indexDirectory","directory","absoluteDir","patterns","map","p","join","files","ignore","nodir","absolute","length","stats","totalFiles","indexedFiles","failedFiles","lastIndexedAt","Date","i","batch","slice","processed","file","result","push","texts","content","embeddings","embedBatch","items","idx","id","relative","vector","Float32Array","upsert","error","message","search","query","limit","embed","results","k","r","score","getStats","count","clear","unlink"],"mappings":"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"}

package/dist/ruvector/embeddings/index.js

@@ -0,0 +1,24 @@
+/**
+ * Embedding Providers Module
+ */ export * from './provider.js';
+export * from './openai.js';
+import { EmbeddingError } from './provider.js';
+import { createOpenAIProvider } from './openai.js';
+export function createEmbeddingProvider(config) {
+    switch(config.provider){
+        case 'openai':
+            return createOpenAIProvider({
+                apiKey: config.apiKey,
+                baseUrl: config.baseUrl,
+                model: config.model,
+                dimensions: config.dimensions
+            });
+        case 'ollama':
+        case 'transformers':
+            throw new EmbeddingError(`${config.provider} provider not yet implemented`, config.provider);
+        default:
+            throw new EmbeddingError(`Unknown provider: ${config.provider}`, 'unknown');
+    }
+}
+
+//# sourceMappingURL=index.js.map

package/dist/ruvector/embeddings/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ruvector/embeddings/index.ts"],"sourcesContent":["/**\n * Embedding Providers Module\n */\n\nexport * from './provider.js';\nexport * from './openai.js';\n\nimport type { EmbeddingProvider, EmbeddingProviderConfig } from './provider.js';\nimport { EmbeddingError } from './provider.js';\nimport { createOpenAIProvider } from './openai.js';\n\nexport function createEmbeddingProvider(config: EmbeddingProviderConfig): EmbeddingProvider {\n  switch (config.provider) {\n    case 'openai':\n      return createOpenAIProvider({\n        apiKey: config.apiKey,\n        baseUrl: config.baseUrl,\n        model: config.model,\n        dimensions: config.dimensions,\n      });\n    case 'ollama':\n    case 'transformers':\n      throw new EmbeddingError(`${config.provider} provider not yet implemented`, config.provider);\n    default:\n      throw new EmbeddingError(`Unknown provider: ${(config as any).provider}`, 'unknown');\n  }\n}"],"names":["EmbeddingError","createOpenAIProvider","createEmbeddingProvider","config","provider","apiKey","baseUrl","model","dimensions"],"mappings":"AAAA;;CAEC,GAED,cAAc,gBAAgB;AAC9B,cAAc,cAAc;AAG5B,SAASA,cAAc,QAAQ,gBAAgB;AAC/C,SAASC,oBAAoB,QAAQ,cAAc;AAEnD,OAAO,SAASC,wBAAwBC,MAA+B;IACrE,OAAQA,OAAOC,QAAQ;QACrB,KAAK;YACH,OAAOH,qBAAqB;gBAC1BI,QAAQF,OAAOE,MAAM;gBACrBC,SAASH,OAAOG,OAAO;gBACvBC,OAAOJ,OAAOI,KAAK;gBACnBC,YAAYL,OAAOK,UAAU;YAC/B;QACF,KAAK;QACL,KAAK;YACH,MAAM,IAAIR,eAAe,GAAGG,OAAOC,QAAQ,CAAC,6BAA6B,CAAC,EAAED,OAAOC,QAAQ;QAC7F;YACE,MAAM,IAAIJ,eAAe,CAAC,kBAAkB,EAAE,AAACG,OAAeC,QAAQ,EAAE,EAAE;IAC9E;AACF"}

package/dist/ruvector/embeddings/openai.js

@@ -0,0 +1,67 @@
+/**
+ * OpenAI Embedding Provider
+ */ import { EmbeddingError } from './provider.js';
+export class OpenAIEmbeddingProvider {
+    name = 'openai';
+    dimensions;
+    apiKey;
+    model;
+    baseUrl;
+    constructor(config){
+        this.apiKey = config.apiKey;
+        this.model = config.model ?? 'text-embedding-3-small';
+        this.baseUrl = config.baseUrl ?? 'https://api.openai.com/v1';
+        this.dimensions = config.dimensions ?? 1536;
+    }
+    async embed(text) {
+        const results = await this.embedBatch([
+            text
+        ]);
+        return results[0];
+    }
+    async embedBatch(texts) {
+        if (texts.length === 0) return [];
+        try {
+            const response = await fetch(`${this.baseUrl}/embeddings`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    input: texts,
+                    dimensions: this.dimensions
+                })
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                throw new EmbeddingError(`OpenAI API error: ${response.status} ${error}`, this.name);
+            }
+            const data = await response.json();
+            const sorted = data.data.sort((a, b)=>a.index - b.index);
+            return sorted.map((item)=>({
+                    embedding: item.embedding,
+                    model: data.model,
+                    tokenCount: Math.floor(data.usage.total_tokens / texts.length)
+                }));
+        } catch (error) {
+            if (error instanceof EmbeddingError) throw error;
+            throw new EmbeddingError(`Failed to generate embeddings: ${error.message}`, this.name, error);
+        }
+    }
+}
+export function createOpenAIProvider(config) {
+    const apiKey = config?.apiKey ?? process.env.OPENAI_API_KEY ?? process.env.ZAI_API_KEY;
+    if (!apiKey) {
+        throw new EmbeddingError('OpenAI API key required. Set OPENAI_API_KEY or ZAI_API_KEY.', 'openai');
+    }
+    const baseUrl = config?.baseUrl ?? (process.env.ZAI_API_KEY ? 'https://api.zai.com/v1' : undefined);
+    return new OpenAIEmbeddingProvider({
+        apiKey,
+        baseUrl,
+        ...config
+    });
+}
+
+//# sourceMappingURL=openai.js.map

package/dist/ruvector/embeddings/openai.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ruvector/embeddings/openai.ts"],"sourcesContent":["/**\n * OpenAI Embedding Provider\n */\n\nimport type { EmbeddingProvider, EmbeddingResult } from './provider.js';\nimport { EmbeddingError } from './provider.js';\n\nexport interface OpenAIEmbeddingConfig {\n  apiKey: string;\n  model?: string;\n  baseUrl?: string;\n  dimensions?: number;\n}\n\nexport class OpenAIEmbeddingProvider implements EmbeddingProvider {\n  readonly name = 'openai';\n  readonly dimensions: number;\n  \n  private readonly apiKey: string;\n  private readonly model: string;\n  private readonly baseUrl: string;\n  \n  constructor(config: OpenAIEmbeddingConfig) {\n    this.apiKey = config.apiKey;\n    this.model = config.model ?? 'text-embedding-3-small';\n    this.baseUrl = config.baseUrl ?? 'https://api.openai.com/v1';\n    this.dimensions = config.dimensions ?? 1536;\n  }\n  \n  async embed(text: string): Promise<EmbeddingResult> {\n    const results = await this.embedBatch([text]);\n    return results[0];\n  }\n  \n  async embedBatch(texts: string[]): Promise<EmbeddingResult[]> {\n    if (texts.length === 0) return [];\n    \n    try {\n      const response = await fetch(`${this.baseUrl}/embeddings`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n          'Authorization': `Bearer ${this.apiKey}`,\n        },\n        body: JSON.stringify({\n          model: this.model,\n          input: texts,\n          dimensions: this.dimensions,\n        }),\n      });\n      \n      if (!response.ok) {\n        const error = await response.text();\n        throw new EmbeddingError(`OpenAI API error: ${response.status} ${error}`, this.name);\n      }\n      \n      const data = await response.json() as {\n        data: Array<{ embedding: number[]; index: number }>;\n        model: string;\n        usage: { total_tokens: number };\n      };\n      \n      const sorted = data.data.sort((a, b) => a.index - b.index);\n      \n      return sorted.map((item) => ({\n        embedding: item.embedding,\n        model: data.model,\n        tokenCount: Math.floor(data.usage.total_tokens / texts.length),\n      }));\n    } catch (error) {\n      if (error instanceof EmbeddingError) throw error;\n      throw new EmbeddingError(\n        `Failed to generate embeddings: ${(error as Error).message}`,\n        this.name,\n        error as Error\n      );\n    }\n  }\n}\n\nexport function createOpenAIProvider(config?: Partial<OpenAIEmbeddingConfig>): OpenAIEmbeddingProvider {\n  const apiKey = config?.apiKey ?? process.env.OPENAI_API_KEY ?? process.env.ZAI_API_KEY;\n  \n  if (!apiKey) {\n    throw new EmbeddingError(\n      'OpenAI API key required. Set OPENAI_API_KEY or ZAI_API_KEY.',\n      'openai'\n    );\n  }\n  \n  const baseUrl = config?.baseUrl ?? (process.env.ZAI_API_KEY ? 'https://api.zai.com/v1' : undefined);\n  \n  return new OpenAIEmbeddingProvider({ apiKey, baseUrl, ...config });\n}"],"names":["EmbeddingError","OpenAIEmbeddingProvider","name","dimensions","apiKey","model","baseUrl","config","embed","text","results","embedBatch","texts","length","response","fetch","method","headers","body","JSON","stringify","input","ok","error","status","data","json","sorted","sort","a","b","index","map","item","embedding","tokenCount","Math","floor","usage","total_tokens","message","createOpenAIProvider","process","env","OPENAI_API_KEY","ZAI_API_KEY","undefined"],"mappings":"AAAA;;CAEC,GAGD,SAASA,cAAc,QAAQ,gBAAgB;AAS/C,OAAO,MAAMC;IACFC,OAAO,SAAS;IAChBC,WAAmB;IAEXC,OAAe;IACfC,MAAc;IACdC,QAAgB;IAEjC,YAAYC,MAA6B,CAAE;QACzC,IAAI,CAACH,MAAM,GAAGG,OAAOH,MAAM;QAC3B,IAAI,CAACC,KAAK,GAAGE,OAAOF,KAAK,IAAI;QAC7B,IAAI,CAACC,OAAO,GAAGC,OAAOD,OAAO,IAAI;QACjC,IAAI,CAACH,UAAU,GAAGI,OAAOJ,UAAU,IAAI;IACzC;IAEA,MAAMK,MAAMC,IAAY,EAA4B;QAClD,MAAMC,UAAU,MAAM,IAAI,CAACC,UAAU,CAAC;YAACF;SAAK;QAC5C,OAAOC,OAAO,CAAC,EAAE;IACnB;IAEA,MAAMC,WAAWC,KAAe,EAA8B;QAC5D,IAAIA,MAAMC,MAAM,KAAK,GAAG,OAAO,EAAE;QAEjC,IAAI;YACF,MAAMC,WAAW,MAAMC,MAAM,GAAG,IAAI,CAACT,OAAO,CAAC,WAAW,CAAC,EAAE;gBACzDU,QAAQ;gBACRC,SAAS;oBACP,gBAAgB;oBAChB,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAACb,MAAM,EAAE;gBAC1C;gBACAc,MAAMC,KAAKC,SAAS,CAAC;oBACnBf,OAAO,IAAI,CAACA,KAAK;oBACjBgB,OAAOT;oBACPT,YAAY,IAAI,CAACA,UAAU;gBAC7B;YACF;YAEA,IAAI,CAACW,SAASQ,EAAE,EAAE;gBAChB,MAAMC,QAAQ,MAAMT,SAASL,IAAI;gBACjC,MAAM,IAAIT,eAAe,CAAC,kBAAkB,EAAEc,SAASU,MAAM,CAAC,CAAC,EAAED,OAAO,EAAE,IAAI,CAACrB,IAAI;YACrF;YAEA,MAAMuB,OAAO,MAAMX,SAASY,IAAI;YAMhC,MAAMC,SAASF,KAAKA,IAAI,CAACG,IAAI,CAAC,CAACC,GAAGC,IAAMD,EAAEE,KAAK,GAAGD,EAAEC,KAAK;YAEzD,OAAOJ,OAAOK,GAAG,CAAC,CAACC,OAAU,CAAA;oBAC3BC,WAAWD,KAAKC,SAAS;oBACzB7B,OAAOoB,KAAKpB,KAAK;oBACjB8B,YAAYC,KAAKC,KAAK,CAACZ,KAAKa,KAAK,CAACC,YAAY,GAAG3B,MAAMC,MAAM;gBAC/D,CAAA;QACF,EAAE,OAAOU,OAAO;YACd,IAAIA,iBAAiBvB,gBAAgB,MAAMuB;YAC3C,MAAM,IAAIvB,eACR,CAAC,+BAA+B,EAAE,AAACuB,MAAgBiB,OAAO,EAAE,EAC5D,IAAI,CAACtC,IAAI,EACTqB;QAEJ;IACF;AACF;AAEA,OAAO,SAASkB,qBAAqBlC,MAAuC;IAC1E,MAAMH,SAASG,QAAQH,UAAUsC,QAAQC,GAAG,CAACC,cAAc,IAAIF,QAAQC,GAAG,CAACE,WAAW;IAEtF,IAAI,CAACzC,QAAQ;QACX,MAAM,IAAIJ,eACR,+DACA;IAEJ;IAEA,MAAMM,UAAUC,QAAQD,WAAYoC,CAAAA,QAAQC,GAAG,CAACE,WAAW,GAAG,2BAA2BC,SAAQ;IAEjG,OAAO,IAAI7C,wBAAwB;QAAEG;QAAQE;QAAS,GAAGC,MAAM;IAAC;AAClE"}

package/dist/ruvector/embeddings/provider.js

@@ -0,0 +1,12 @@
+/**
+ * Embedding Provider Interface for RuVector
+ */ export class EmbeddingError extends Error {
+    provider;
+    cause;
+    constructor(message, provider, cause){
+        super(message), this.provider = provider, this.cause = cause;
+        this.name = 'EmbeddingError';
+    }
+}
+
+//# sourceMappingURL=provider.js.map

package/dist/ruvector/embeddings/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ruvector/embeddings/provider.ts"],"sourcesContent":["/**\n * Embedding Provider Interface for RuVector\n */\n\nexport interface EmbeddingResult {\n  embedding: number[];\n  model: string;\n  tokenCount?: number;\n}\n\nexport interface EmbeddingProvider {\n  readonly name: string;\n  readonly dimensions: number;\n  embed(text: string): Promise<EmbeddingResult>;\n  embedBatch(texts: string[]): Promise<EmbeddingResult[]>;\n}\n\nexport interface EmbeddingProviderConfig {\n  provider: 'openai' | 'ollama' | 'transformers';\n  model?: string;\n  apiKey?: string;\n  baseUrl?: string;\n  dimensions?: number;\n}\n\nexport class EmbeddingError extends Error {\n  constructor(\n    message: string,\n    public readonly provider: string,\n    public readonly cause?: Error\n  ) {\n    super(message);\n    this.name = 'EmbeddingError';\n  }\n}"],"names":["EmbeddingError","Error","message","provider","cause","name"],"mappings":"AAAA;;CAEC,GAuBD,OAAO,MAAMA,uBAAuBC;;;IAClC,YACEC,OAAe,EACf,AAAgBC,QAAgB,EAChC,AAAgBC,KAAa,CAC7B;QACA,KAAK,CAACF,eAHUC,WAAAA,eACAC,QAAAA;QAGhB,IAAI,CAACC,IAAI,GAAG;IACd;AACF"}

package/dist/ruvector/index.js

@@ -0,0 +1,9 @@
+/**
+ * RuVector - Semantic codebase search for CFN
+ */ // Core
+export { RuVectorIndex } from './core/index.js';
+export { createFileProcessor } from './core/file-processor.js';
+// Embeddings
+export { EmbeddingError, createEmbeddingProvider, OpenAIEmbeddingProvider, createOpenAIProvider } from './embeddings/index.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ruvector/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ruvector/index.ts"],"sourcesContent":["/**\n * RuVector - Semantic codebase search for CFN\n */\n\n// Core\nexport { RuVectorIndex } from './core/index.js';\nexport type { SearchResult, IndexStats, RuVectorIndexOptions } from './core/index.js';\nexport { createFileProcessor } from './core/file-processor.js';\nexport type { ProcessedFile, FileProcessor } from './core/file-processor.js';\n\n// Embeddings\nexport { EmbeddingError, createEmbeddingProvider, OpenAIEmbeddingProvider, createOpenAIProvider } from './embeddings/index.js';\nexport type { EmbeddingProvider, EmbeddingResult, EmbeddingProviderConfig } from './embeddings/index.js';"],"names":["RuVectorIndex","createFileProcessor","EmbeddingError","createEmbeddingProvider","OpenAIEmbeddingProvider","createOpenAIProvider"],"mappings":"AAAA;;CAEC,GAED,OAAO;AACP,SAASA,aAAa,QAAQ,kBAAkB;AAEhD,SAASC,mBAAmB,QAAQ,2BAA2B;AAG/D,aAAa;AACb,SAASC,cAAc,EAAEC,uBAAuB,EAAEC,uBAAuB,EAAEC,oBAAoB,QAAQ,wBAAwB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.18.2",
+  "version": "2.18.3",
   "description": "AI agent orchestration framework with namespace-isolated skills, agents, and CFN Loop validation. Safe installation with ~0.01% collision risk.",
   "main": "dist/index.js",
   "type": "module",
@@ -13,7 +13,8 @@
     "cfn-portal": "dist/cli/cfn-portal.js",
     "cfn-context": "dist/cli/cfn-context.js",
     "cfn-metrics": "dist/cli/cfn-metrics.js",
-    "cfn-redis": "dist/cli/cfn-redis.js"
+    "cfn-redis": "dist/cli/cfn-redis.js",
+    "cfn-ruvector": "dist/ruvector/cli.js"
   },
   "files": [
     "dist/",
@@ -89,7 +90,10 @@
     "docker",
     "containers",
     "memory-leaks",
-    "concurrent-execution"
+    "concurrent-execution",
+    "semantic-search",
+    "ruvector",
+    "vector-embeddings"
   ],
   "author": "Claude Flow Novice Team",
   "license": "MIT",
@@ -105,7 +109,7 @@
     "dev": "tsx src/cli/index.ts",
     "build": "npm run clean && npm run build:swc && npm run build:orchestrator",
     "build:swc": "swc src -d dist --config-file .swcrc --ignore '**/*.test.ts' --ignore '**/*.test.tsx' --ignore '**/*.spec.ts'",
-    "build:orchestrator": "(cd .claude/skills/cfn-loop-orchestration && npm run build || true) || echo 'Orchestrator build skipped (optional)'",
+    "build:orchestrator": "cd .claude/skills/cfn-loop-orchestration && npm run build 2>/dev/null || echo 'Orchestrator build skipped (optional)'",
     "build:all": "npm run build && npm run build:spawner && npm run build:selector && npm run build:coordination",
     "build:spawner": "cd src/coordination && tsc spawn-agent.ts --outDir ../../dist/coordination --module commonjs --target es2020 --skipLibCheck 2>/dev/null || echo 'Spawner build skipped'",
     "build:selector": "cd .claude/skills/cfn-agent-selection-with-fallback && npm run build 2>/dev/null || echo 'Selector build skipped'",
@@ -183,7 +187,11 @@
     "socket.io": "^4.8.1",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7",
-    "uuid": "^10.0.0"
+    "uuid": "^10.0.0",
+    "@ruvector/core": "^0.1.0",
+    "simple-git": "^3.22.0",
+    "cosmiconfig": "^9.0.0",
+    "zod": "^3.22.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/readme/README.md

@@ -1,16 +1,16 @@
-# Claude Flow Novice v2.16.0 Documentation
+# Claude Flow Novice v2.18.1 Documentation
 
-**Version:** 2.16.0 (Integration Standardization)
-**Last Updated:** 2025-11-17
+**Version:** 2.18.1 (RuVector Integration)
+**Last Updated:** 2025-12-05
 
 **Package Metrics**:
-- 2.4 MB unpacked
-- 303 files
-- Namespace-isolated installation
+- Namespace-isolated installation (~0.01% collision risk)
+- Semantic codebase search via RuVector
+- Multi-provider routing (Z.ai, Kimi, OpenRouter, Anthropic)
 
 ## Overview
 
-Claude Flow Novice is a production-ready AI agent orchestration framework built on a skills-first architecture with Redis-based coordination, zero-token waiting mechanisms, and multi-loop consensus validation (CFN Loop).
+AI agent orchestration with semantic codebase search, Redis coordination, and multi-loop consensus validation (CFN Loop).
 
 ## CFN Loop Execution Modes
 
@@ -85,7 +85,7 @@ npx claude-flow-novice swarm "Task Description" \
 ### Core Concepts
 - **[Skills System](log-skills.md)** - Modular, reusable agent capabilities
 - **[CFN Loop](cfn-loop-modes.md)** - Three-loop consensus validation framework
-- **[CFN Loop Task Mode](claude-assets/commands/CFN_LOOP_TASK_MODE.md)** - Task execution guide with agent specialization
+- **[RuVector Search](../docs/RUVECTOR_ARCHITECTURE.md)** - Semantic codebase indexing
 - **[Redis Coordination](logs-cli-redis.md)** - Zero-token agent coordination
 
 ### User Guides
@@ -111,14 +111,24 @@ npx claude-flow-novice swarm "Task Description" \
 - **[Deprecated MCP Logs](deprecated-logs-mcp.md)** - Historical MCP implementation
 - **[v1 Documentation](../legacy/readme-v1/)** - Previous documentation version
 
-## Key Features (v2.16.0)
+## Key Features (v2.18.1)
 
-### Integration Standardization (NEW - 90% Complete)
-- **Skill Lifecycle Automation**: Deploy, version, promote skills with single command
-- **Cross-Database Transactions**: Coordinated PostgreSQL + SQLite + Redis operations
-- **File System Standardization**: Unified backups, logging, state persistence
-- **Edge Case Auto-Patching**: Feedback loop generates patches from test failures
-- **Data Format Harmonization**: Consistent JSON schemas across all skill outputs
+### RuVector Codebase Search (NEW)
+- **Semantic Search**: Natural language queries against codebase
+- **OpenAI Embeddings**: text-embedding-3-small (1536 dimensions)
+- **Manifest System**: `.cfn-manifest.json` tracks CFN vs custom files
+- **Safe Distribution**: Custom files preserved during CFN updates
+
+```bash
+# Index codebase
+./.claude/skills/cfn-ruvector-codebase-index/index.sh --full
+
+# Search
+./.claude/skills/cfn-ruvector-codebase-index/search.sh "authentication" --top 5
+
+# Incremental reindex
+/cfn-ruvector:codebase-reindex
+```
 
 ### Skills-First Architecture
 - **Modular Skills**: Independently maintainable, testable capabilities