recker 1.0.43 → 1.0.44-next.084c2ef

package/dist/cli/commands/vector.js

@@ -0,0 +1,158 @@
+import colors from '../../utils/colors.js';
+import { RekArgs, generateHelp } from '../parser/index.js';
+import { MemoryVectorStore } from '../../ai/vector/store.js';
+import { promises as fs } from 'node:fs';
+const vectorSchema = {
+    name: 'vector',
+    description: 'Manage a local vector store for RAG (Retrieval-Augmented Generation).\nStores embeddings in a local JSON file.',
+    params: {
+        file: { type: 'string', default: 'vectors.json', description: 'Vector store file path' },
+        content: { type: 'string', description: 'Text content to add' },
+        query: { type: 'string', description: 'Search query' },
+        limit: { type: 'number', default: 3, description: 'Search limit' },
+        threshold: { type: 'number', default: 0.0, description: 'Similarity threshold (0-1)' },
+        metadata: { type: 'json', description: 'Metadata JSON for added content' },
+        model: { type: 'string', description: 'Embedding model' },
+        provider: { type: 'string', description: 'AI Provider (openai, google, ollama)' }
+    },
+    flags: {
+        json: { description: 'Output JSON', alias: 'j' },
+        clear: { description: 'Clear store before operation' }
+    },
+    examples: [
+        { cmd: 'rek vector add content="Recker is a network tool" file=data.json', desc: 'Add document' },
+        { cmd: 'rek vector search query="network tool" file=data.json limit:=1', desc: 'Search' },
+        { cmd: 'rek vector info file=data.json', desc: 'Show stats' }
+    ]
+};
+async function loadStore(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+}
+async function saveStore(filePath, docs) {
+    await fs.writeFile(filePath, JSON.stringify(docs, null, 2), 'utf-8');
+}
+export function registerVectorCommand(program) {
+    const vector = program.command('vector')
+        .description(vectorSchema.description)
+        .addHelpText('after', generateHelp(vectorSchema));
+    const handleVector = async (command, rawArgs) => {
+        const { data, options, args } = RekArgs.parse(rawArgs, vectorSchema);
+        const filePath = data.file;
+        const existingDocs = await loadStore(filePath);
+        const { createClient } = await import('../../core/client.js');
+        const { createAI } = await import('../../ai/index.js');
+        const needsAI = command === 'add' || command === 'search';
+        let aiClient;
+        if (needsAI) {
+            try {
+                aiClient = createAI({
+                    defaultProvider: data.provider,
+                });
+            }
+            catch (e) {
+                console.error(colors.red(`AI Initialization Failed: ${e.message}`));
+                console.log(colors.gray('Ensure you have OPENAI_API_KEY or other provider keys set.'));
+                process.exit(1);
+            }
+        }
+        const store = new MemoryVectorStore({
+            client: aiClient,
+            model: data.model
+        });
+        if (existingDocs.length > 0) {
+            await store.add(existingDocs);
+        }
+        if (command === 'info') {
+            console.log(colors.cyan(`Vector Store: ${filePath}`));
+            console.log(`Documents: ${store.count}`);
+            if (options.json) {
+                console.log(JSON.stringify(existingDocs, null, 2));
+            }
+            return;
+        }
+        if (command === 'clear') {
+            store.clear();
+            await saveStore(filePath, []);
+            console.log(colors.green(`Cleared vector store at ${filePath}`));
+            return;
+        }
+        if (command === 'add') {
+            if (!data.content && args.length === 0) {
+                console.error(colors.red('Error: content=... is required'));
+                process.exit(1);
+            }
+            const content = data.content || args.join(' ');
+            const metadata = data.metadata || {};
+            console.log(colors.gray(`Generating embedding for: "${content.slice(0, 50)}"...`));
+            await store.add([
+                {
+                    content,
+                    metadata
+                }
+            ]);
+            const allDocs = Array.from(store.documents.values());
+            await saveStore(filePath, allDocs);
+            console.log(colors.green(`✔ Added document. Total: ${store.count}`));
+        }
+        if (command === 'search') {
+            if (!data.query && args.length === 0) {
+                console.error(colors.red('Error: query=... is required'));
+                process.exit(1);
+            }
+            const query = data.query || args.join(' ');
+            console.log(colors.gray(`Searching for: "${query}"...`));
+            const results = await store.search(query, data.limit, data.threshold);
+            if (options.json) {
+                console.log(JSON.stringify(results, null, 2));
+                return;
+            }
+            console.log(`
+${colors.bold(colors.cyan('Search Results'))} (${results.length})
+`);
+            results.forEach((res, i) => {
+                const score = (res.score * 100).toFixed(1) + '%';
+                const color = res.score > 0.8 ? colors.green : res.score > 0.5 ? colors.yellow : colors.gray;
+                console.log(`${i + 1}. ${color(score)} - ${res.id}`);
+                console.log(`   ${res.content.slice(0, 100).replace(/\n/g, ' ')}...`);
+                if (res.metadata && Object.keys(res.metadata).length > 0) {
+                    console.log(`   ${colors.gray(JSON.stringify(res.metadata))}`);
+                }
+                console.log('');
+            });
+        }
+    };
+    vector.command('add')
+        .description('Add a document to the store')
+        .argument('[content]', 'Text content')
+        .argument('[args...]', 'Options: file=x metadata:=json')
+        .action(async (content, rawArgs) => {
+        const args = content ? [content, ...rawArgs] : rawArgs;
+        await handleVector('add', args);
+    });
+    vector.command('search')
+        .description('Search the vector store')
+        .argument('[query]', 'Search query')
+        .argument('[args...]', 'Options: file=x limit=3')
+        .action(async (query, rawArgs) => {
+        const args = query ? [query, ...rawArgs] : rawArgs;
+        await handleVector('search', args);
+    });
+    vector.command('info')
+        .description('Show store statistics')
+        .argument('[args...]', 'Options: file=x')
+        .action(async (rawArgs) => {
+        await handleVector('info', rawArgs);
+    });
+    vector.command('clear')
+        .description('Clear the vector store')
+        .argument('[args...]', 'Options: file=x')
+        .action(async (rawArgs) => {
+        await handleVector('clear', rawArgs);
+    });
+}

package/dist/cli/handler.d.ts

@@ -1,12 +1,12 @@
 interface RequestOptions {
     method: string;
     url: string;
-    headers: Record<string, string>;
+    headers?: Record<string, string>;
     body?: any;
     verbose?: boolean;
     quiet?: boolean;
     output?: string;
-    presetConfig?: any;
+    clientOptions?: any;
 }
 export declare function handleRequest(options: RequestOptions): Promise<void>;
 export {};

package/dist/cli/handler.js

@@ -30,19 +30,19 @@ export async function handleRequest(options) {
     const start = performance.now();
     try {
         let client;
-        if (options.presetConfig) {
-            client = createClient(options.presetConfig);
-        }
-        else {
+        const finalClientOptions = options.clientOptions || {};
+        if (!finalClientOptions.baseUrl && !finalClientOptions.base) {
             try {
                 const urlObj = new URL(options.url);
-                client = createClient({ baseUrl: urlObj.origin });
+                finalClientOptions.baseUrl = urlObj.origin;
             }
             catch {
-                client = createClient();
             }
         }
+        finalClientOptions.headers = { ...finalClientOptions.headers, ...options.headers };
+        client = createClient(finalClientOptions);
         let requestBody = undefined;
+        options.headers = options.headers || {};
         if (options.body) {
             if (typeof options.body === 'string') {
                 requestBody = options.body;

package/dist/cli/helpers.d.ts

@@ -1,5 +1,10 @@
 import { classifyError as classifyErrorCore, ClassifiedError } from '../core/error-handler.js';
 export { classifyErrorCore as classifyError };
+import type { ClientOptions } from '../types/index.js';
+export declare function parseEnhancerPresets(args: string[]): Promise<{
+    clientOptions: Partial<ClientOptions>;
+    remainingArgs: string[];
+}>;
 import colors from '../utils/colors.js';
 export { colors };
 export declare function formatCliError(error: Error | string | unknown, context?: Record<string, unknown>): string;
@@ -52,3 +57,5 @@ export declare function formatDuration(ms: number): string;
 export declare function formatBytes(bytes: number): string;
 export declare const COMMAND_HELP: Record<string, HelpConfig>;
 export declare function getCommandHelp(command: string): string | null;
+export declare function loadEnvFile(filePath?: string | boolean): Promise<Record<string, string>>;
+export declare function levenshtein(a: string, b: string): number;

package/dist/cli/helpers.js

@@ -1,5 +1,58 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
 import { classifyError as classifyErrorCore, formatErrorForTerminal, } from '../core/error-handler.js';
 export { classifyErrorCore as classifyError };
+import { resolvePreset } from './presets.js';
+import { getGlobalPresets } from './router.js';
+function deepMergeClientOptions(target, source) {
+    const output = { ...target };
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const targetValue = output[key];
+            const sourceValue = source[key];
+            if (sourceValue && typeof sourceValue === 'object' && !Array.isArray(sourceValue) && targetValue && typeof targetValue === 'object' && !Array.isArray(targetValue)) {
+                output[key] = deepMergeClientOptions(targetValue, sourceValue);
+            }
+            else {
+                output[key] = sourceValue;
+            }
+        }
+    }
+    return output;
+}
+export async function parseEnhancerPresets(args) {
+    let mergedOptions = {};
+    const remainingArgs = [];
+    const presetsToResolve = [...getGlobalPresets()];
+    for (const arg of args) {
+        if (arg.startsWith('+')) {
+            presetsToResolve.push(arg.slice(1));
+        }
+        else {
+            remainingArgs.push(arg);
+        }
+    }
+    for (const presetName of presetsToResolve) {
+        try {
+            const options = await resolvePreset(presetName);
+            if (options) {
+                if (process.env.DEBUG)
+                    console.log(`[debug] Merging preset +${presetName}`, options);
+                mergedOptions = deepMergeClientOptions(mergedOptions, options);
+            }
+            else {
+                if (process.env.DEBUG)
+                    console.log(`[debug] Preset +${presetName} resolved to null`);
+            }
+        }
+        catch (err) {
+            console.warn(colors.yellow(`Warning: Failed to load preset '+${presetName}': ${err.message}`));
+            if (process.env.DEBUG)
+                console.error(err);
+        }
+    }
+    return { clientOptions: mergedOptions, remainingArgs };
+}
 import colors from '../utils/colors.js';
 export { colors };
 export function formatCliError(error, context) {
@@ -514,6 +567,20 @@ export const COMMAND_HELP = {
         ],
         seeAlso: ['shell'],
     },
+    vector: {
+        name: 'Vector Store',
+        description: 'Manage local vector store for RAG',
+        usage: [
+            { command: 'rek vector add', args: 'content="..."', description: 'Add document' },
+            { command: 'rek vector search', args: 'query="..."', description: 'Search documents' },
+            { command: 'rek vector info', args: '', description: 'Show stats' },
+            { command: 'rek vector clear', args: '', description: 'Clear store' }
+        ],
+        examples: [
+            { command: 'rek vector add content="Deployment guide" file=docs.json', description: 'Add text' },
+            { command: 'rek vector search query="deploy" limit=1', description: 'Search text' }
+        ]
+    },
     bench: {
         name: 'Bench',
         description: 'Performance benchmarking tools',
@@ -546,3 +613,64 @@ export function getCommandHelp(command) {
         return null;
     return buildHelpText(help);
 }
+export async function loadEnvFile(filePath) {
+    const envPath = typeof filePath === 'string' ? filePath : join(process.cwd(), '.env');
+    const envVars = {};
+    try {
+        const content = await fs.readFile(envPath, 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const match = trimmed.match(/^([^=]+)=(.*)$/);
+            if (match) {
+                const [, key, value] = match;
+                const cleanKey = key.trim();
+                let cleanValue = value.trim();
+                if ((cleanValue.startsWith('"') && cleanValue.endsWith('"')) ||
+                    (cleanValue.startsWith("'") && cleanValue.endsWith("'"))) {
+                    cleanValue = cleanValue.slice(1, -1);
+                }
+                envVars[cleanKey] = cleanValue;
+                process.env[cleanKey] = cleanValue;
+            }
+        }
+        console.log(colors.gray(`Loaded ${Object.keys(envVars).length} variables from ${envPath}`));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            if (filePath !== undefined && filePath !== true) {
+                console.log(colors.yellow(`Warning: No .env file found at ${envPath}`));
+            }
+        }
+        else {
+            console.log(colors.red(`Error loading .env: ${error.message}`));
+        }
+    }
+    return envVars;
+}
+export function levenshtein(a, b) {
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}