@operor/cli 0.1.0

package/src/commands/llm-override.ts

@@ -0,0 +1,480 @@
+/** Approximate cost per 1M tokens by model name (input / output). */
+const MODEL_COST_PER_M: Record<string, { input: number; output: number }> = {
+  'gpt-5.2': { input: 1.25, output: 5 },
+  'gpt-5-mini': { input: 0.25, output: 2 },
+  'gpt-5-nano': { input: 0.05, output: 0.4 },
+  'gpt-4o': { input: 2.5, output: 10 },
+  'gpt-4o-mini': { input: 0.15, output: 0.6 },
+  'gpt-4-turbo': { input: 10, output: 30 },
+  'gpt-4': { input: 30, output: 60 },
+  'gpt-3.5-turbo': { input: 0.5, output: 1.5 },
+  'claude-sonnet-4-5-20250929': { input: 3, output: 15 },
+  'claude-opus-4-20250514': { input: 15, output: 75 },
+  'claude-haiku-3-5-20241022': { input: 0.8, output: 4 },
+  'gemini-2.0-flash': { input: 0.1, output: 0.4 },
+  'gemini-1.5-pro': { input: 1.25, output: 5 },
+};
+
+/** Estimate cost in USD from token counts and model name. Returns 0 if model unknown. */
+export function estimateCost(promptTokens: number, completionTokens: number, model: string): number {
+  // Try exact match first, then prefix match (e.g. "gpt-4o-2024-08-06" → "gpt-4o")
+  const rates = MODEL_COST_PER_M[model]
+    || Object.entries(MODEL_COST_PER_M).find(([k]) => model.startsWith(k))?.[1];
+  if (!rates) return 0;
+  return (promptTokens * rates.input + completionTokens * rates.output) / 1_000_000;
+}
+
+/** Extract image media from an MCP tool result, returning a clean text summary for the LLM. */
+function extractMediaFromToolResult(result: any): { cleanResult: any; media?: { buffer: Buffer; fileName: string; mimeType: string } } {
+  if (!result || !result.content || !Array.isArray(result.content)) {
+    return { cleanResult: result };
+  }
+
+  for (const item of result.content) {
+    // Standard MCP image content type
+    if (item.type === 'image' && item.data) {
+      const buffer = Buffer.from(item.data, 'base64');
+      const mimeType = item.mimeType || 'image/png';
+      const ext = mimeType.split('/')[1] || 'png';
+      const cleanContent = result.content
+        .filter((c: any) => c.type !== 'image')
+        .concat([{ type: 'text', text: `Screenshot captured successfully (${buffer.length} bytes)` }]);
+      return {
+        cleanResult: { ...result, content: cleanContent },
+        media: { buffer, fileName: `screenshot.${ext}`, mimeType },
+      };
+    }
+
+    // Crawl4AI format: screenshot embedded in a JSON text string
+    if (item.type === 'text' && typeof item.text === 'string') {
+      try {
+        const parsed = JSON.parse(item.text);
+        if (parsed.screenshot && typeof parsed.screenshot === 'string') {
+          // Base64 data (long strings)
+          if (parsed.screenshot.length > 1000) {
+            const buffer = Buffer.from(parsed.screenshot, 'base64');
+            const { screenshot: _, ...rest } = parsed;
+            rest.screenshot_captured = true;
+            rest.screenshot_size = buffer.length;
+            const cleanContent = result.content.map((c: any) =>
+              c === item ? { type: 'text', text: JSON.stringify(rest) } : c
+            );
+            return {
+              cleanResult: { ...result, content: cleanContent },
+              media: { buffer, fileName: 'screenshot.png', mimeType: 'image/png' },
+            };
+          }
+
+          // File path (short string matching image path pattern)
+          if (/^\/.*\.(png|jpe?g|webp|gif)$/i.test(parsed.screenshot)) {
+            try {
+              const fs = require('fs');
+              if (fs.existsSync(parsed.screenshot)) {
+                const buffer = fs.readFileSync(parsed.screenshot);
+                const ext = parsed.screenshot.split('.').pop() || 'png';
+                const mimeType = `image/${ext === 'jpg' ? 'jpeg' : ext}`;
+                const { screenshot: _, ...rest } = parsed;
+                rest.screenshot_captured = true;
+                rest.screenshot_size = buffer.length;
+                const cleanContent = result.content.map((c: any) =>
+                  c === item ? { type: 'text', text: JSON.stringify(rest) } : c
+                );
+                return {
+                  cleanResult: { ...result, content: cleanContent },
+                  media: { buffer, fileName: `screenshot.${ext}`, mimeType },
+                };
+              }
+            } catch {
+              // File not accessible, fall through
+            }
+          }
+        }
+      } catch {
+        // Not JSON, skip
+      }
+    }
+  }
+
+  return { cleanResult: result };
+}
+
+/**
+ * When a crawl4ai tool returns empty content, retry using fetchContent() from @operor/knowledge.
+ * This is the same path /learn-url uses — it calls the /crawl endpoint with full browser rendering,
+ * then falls back to Readability. Returns null if not applicable or if retry also fails.
+ */
+export async function retryCrawlWithFetchContent(
+  toolName: string,
+  toolArgs: Record<string, any>,
+  toolResult: any,
+  deps?: { fetchContentFn?: (url: string, opts: any) => Promise<any> },
+): Promise<any | null> {
+  // Only retry for crawl4ai tools
+  if (!/^crawl4ai/i.test(toolName)) return null;
+
+  // Must have a url argument to retry
+  const url = toolArgs?.url;
+  if (!url) return null;
+
+  // Check if the result is empty
+  if (!isCrawlResultEmpty(toolResult)) return null;
+
+  console.log(`[Operor] 🔄 crawl4ai returned empty for ${url}, retrying with fetchContent...`);
+
+  try {
+    const fetchContentFn = deps?.fetchContentFn
+      ?? (await import('@operor/knowledge')).fetchContent;
+
+    const { title, content, isMarkdown } = await fetchContentFn(url, {});
+
+    if (!content || content.trim().length === 0) {
+      console.log(`[Operor] ⚠️  fetchContent also returned empty for ${url}`);
+      return null;
+    }
+
+    // Trim to ~8k chars to avoid blowing up the context window
+    const trimmed = content.length > 8000
+      ? content.slice(0, 8000) + '\n\n[Content truncated]'
+      : content;
+
+    console.log(`[Operor] ✅ fetchContent got ${content.length} chars for "${title || url}"`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ title, content: trimmed, url, source: 'fetchContent-fallback' }) }],
+    };
+  } catch (err: any) {
+    console.warn(`[Operor] ⚠️  fetchContent fallback failed for ${url}:`, err.message);
+    return null;
+  }
+}
+
+function isCrawlResultEmpty(result: any): boolean {
+  if (!result) return true;
+  const content = result?.content;
+  if (!content || !Array.isArray(content) || content.length === 0) return true;
+  // Check if all text entries are empty
+  return content.every((c: any) => !c.text || c.text.trim().length === 0);
+}
+
+/**
+ * Shared LLM override for agent.process — used by simulate, converse, and start commands.
+ * Replaces the default pattern-matching with real LLM-powered responses + multi-turn tool calling.
+ */
+export function applyLLMOverride(
+  agent: any,
+  llm: any,
+  allTools: any[],
+  options?: {
+    systemPrompt?: string;
+    kbRuntime?: any;
+    useKB?: boolean;
+    guardrails?: { systemRules?: string[]; blockedTopics?: string[]; escalationTriggers?: string[]; maxResponseLength?: number };
+    promptSkills?: Array<{name: string, content: string}>;
+  },
+): void {
+  // Log skills once at setup time
+  if (options?.promptSkills?.length) {
+    console.log(`[Operor] 📝 Prompt skills for ${agent.config.name}: ${options.promptSkills.map(s => s.name).join(', ')}`);
+  }
+  if (allTools.length > 0) {
+    console.log(`[Operor] 🔧 MCP tools for ${agent.config.name}: ${allTools.map((t: any) => t.name).join(', ')}`);
+  }
+
+  agent.process = async (context: any) => {
+    const startTime = Date.now();
+    if (options?.promptSkills?.length) {
+      console.log(`[Operor] 📝 Prompt skills (injected into system prompt): ${options.promptSkills.map(s => s.name).join(', ')}`);
+    }
+    if (allTools.length > 0) {
+      console.log(`[Operor] 🔧 MCP tools (${allTools.length} available): ${allTools.map((t: any) => t.name).join(', ')}`);
+    }
+    try {
+      // Build system message: use provided systemPrompt or fall back to personality/purpose
+      let systemMessage = options?.systemPrompt
+        ?? `You are a ${agent.config.personality} customer support agent. ${agent.config.purpose}.`;
+
+      // Inject response length guidance so the LLM naturally keeps responses concise
+      if (options?.guardrails?.maxResponseLength) {
+        const limit = options.guardrails.maxResponseLength;
+        systemMessage += `\n\n## Response Length\n\nKeep your responses concise and under ${limit} characters. `
+          + 'This is a messaging app — users prefer short, clear answers. '
+          + 'Use short paragraphs. Avoid long lists or verbose explanations. '
+          + 'If the answer requires more detail, provide the key points and offer to elaborate.';
+      }
+
+      // KB metadata for copilot tracking
+      let kbMetadata: Record<string, any> | undefined;
+
+      // Inject KB context if available.
+      // When useKB is provided, only retrieve when true; otherwise retrieve whenever kbRuntime exists.
+      const shouldRetrieveKB = options?.kbRuntime && (options?.useKB !== undefined ? options.useKB : true);
+      if (shouldRetrieveKB) {
+        try {
+          const kbStart = Date.now();
+          console.log('[Operor] 📚 KB: retrieving context for:', context.currentMessage.text.substring(0, 80));
+          const kbResult = await options!.kbRuntime.retrieve(context.currentMessage.text);
+          console.log(`[Operor] 📚 KB: retrieval completed in ${((Date.now() - kbStart) / 1000).toFixed(1)}s`);
+          const topResult = kbResult.results?.[0];
+          kbMetadata = {
+            kbTopScore: topResult?.score ?? 0,
+            kbIsFaqMatch: !!kbResult.isFaqMatch,
+            kbTopChunkContent: topResult?.chunk?.content,
+            kbResultCount: kbResult.results?.length ?? 0,
+            kbFaqMatchCount: kbResult.faqMatches?.length ?? 0,
+          };
+          const topScore = kbResult.results?.[0]?.score ?? 0;
+          if (kbResult.context && topScore >= 0.50) {
+            console.log(`[Operor] 📚 KB: found results, isFaqMatch=${kbResult.isFaqMatch}, topScore=${topScore.toFixed(3)}, faqAnswer=${kbResult.faqAnswer ?? '(undefined)'}`);
+            if (kbResult.isFaqMatch) {
+              // When we have multiple FAQ matches from compound query splitting,
+              // build a combined override with all answers
+              if (kbResult.faqMatches && kbResult.faqMatches.length > 1) {
+                const faqList = kbResult.faqMatches
+                  .map((m: any, i: number) => `${i + 1}. **Q:** ${m.faqQuestion}\n   **A:** ${m.faqAnswer}`)
+                  .join('\n');
+                const faqOverride = '## CRITICAL OVERRIDE — Multiple FAQ Answers\n\n'
+                  + 'Multiple verified FAQ entries match the user\'s question.\n\n'
+                  + faqList + '\n\n'
+                  + 'RULES:\n'
+                  + '1. You MUST include ALL the above answers in your response.\n'
+                  + '2. Do NOT correct, rephrase, or "fix" the answers — the business owner wrote them intentionally.\n'
+                  + '3. Combine them naturally in a single response.\n'
+                  + '4. Do NOT substitute your own knowledge for the required answers.\n'
+                  + '5. If Skill Instructions below provide conflicting guidance, follow the Skill Instructions instead.\n\n---\n\n';
+                systemMessage = faqOverride + systemMessage;
+              } else if (kbResult.faqAnswer) {
+                const faqOverride = '## CRITICAL OVERRIDE — FAQ Answer\n\n'
+                  + 'A verified FAQ entry exactly matches the user\'s question.\n\n'
+                  + (kbResult.faqQuestion ? `**User asked:** ${kbResult.faqQuestion}\n` : '')
+                  + `**Required answer (verbatim):** ${kbResult.faqAnswer}\n\n`
+                  + 'RULES:\n'
+                  + '1. You MUST include the EXACT wording from the required answer above in your response.\n'
+                  + '2. Do NOT correct, rephrase, or "fix" the answer — even if it looks like a typo or unusual value. '
+                  + 'The business owner wrote this answer intentionally.\n'
+                  + '3. You may add a brief friendly sentence around it, but the core answer must appear word-for-word.\n'
+                  + '4. Do NOT substitute your own knowledge for the required answer.\n'
+                  + '5. If Skill Instructions below provide conflicting guidance, follow the Skill Instructions instead.\n\n---\n\n';
+                systemMessage = faqOverride + systemMessage;
+              } else {
+                // Fallback: parse answer from the Q/A content format
+                const topChunk = kbResult.results?.[0]?.chunk?.content || '';
+                const answerMatch = topChunk.match(/^A:\s*(.+)$/m);
+                if (answerMatch) {
+                  const faqOverride = '## CRITICAL OVERRIDE — FAQ Answer\n\n'
+                    + `**Required answer:** ${answerMatch[1].trim()}\n\n`
+                    + 'You MUST respond with the above answer. Do NOT ignore it.\n'
+                    + 'If Skill Instructions below provide conflicting guidance, follow the Skill Instructions instead.\n\n---\n\n';
+                  systemMessage = faqOverride + systemMessage;
+                } else {
+                  systemMessage += '\n\n## Knowledge Base Context (FAQ Match)\n\n'
+                    + 'The following FAQ answer was found that directly matches the user\'s question. '
+                    + 'You MUST use this answer as the basis of your response. Do not ignore it or make up a different answer.\n\n'
+                    + kbResult.context;
+                }
+              }
+            } else {
+              // Not a high-confidence FAQ match, but check if the top result is still
+              // an FAQ document — if so, surface the answer more prominently than
+              // generic KB context so the LLM doesn't ignore it.
+              const topResult = kbResult.results?.[0];
+              const topIsFaq = topResult?.document?.sourceType === 'faq';
+              const faqAns = topIsFaq && (topResult.chunk?.metadata?.answer || topResult.document?.metadata?.answer);
+
+              if (faqAns) {
+                const faqQ = topResult.chunk?.metadata?.question || topResult.document?.metadata?.question;
+                const faqOverride = '## FAQ Reference\n\n'
+                  + 'A relevant FAQ entry was found in the knowledge base.\n\n'
+                  + (faqQ ? `**FAQ question:** ${faqQ}\n` : '')
+                  + `**FAQ answer:** ${faqAns}\n\n`
+                  + 'You SHOULD use this FAQ answer as the basis of your response unless the user is clearly asking about something different.\n\n---\n\n';
+                systemMessage = faqOverride + systemMessage;
+              } else {
+                systemMessage += '\n\n## Knowledge Base Context\n\n'
+                  + 'The following information was retrieved from the knowledge base. '
+                  + 'If it contains information relevant to the user\'s question, you MUST use it to answer. '
+                  + 'Do NOT say you don\'t have information if the answer is present below.\n\n'
+                  + kbResult.context;
+                if (allTools.length > 0) {
+                  systemMessage += '\n\nNote: You also have tools available. If the KB context does not fully answer the user\'s question, use your tools to look up the information.';
+                }
+              }
+            }
+          } else {
+            console.log('[Operor] 📚 KB: no relevant context found');
+            const hasTools = allTools.length > 0;
+            const noKbOverride = '## CRITICAL OVERRIDE — No Knowledge Base Match\n\n'
+              + 'The knowledge base was searched and contains NO relevant information for this query.\n\n'
+              + 'RULES:\n'
+              + '1. You MUST NOT make up, guess, or fabricate any information.\n'
+              + '2. You MUST NOT pretend to know the answer.\n'
+              + (hasTools
+                ? '3. However, you HAVE tools available. If the user\'s request can be answered by calling a tool (e.g. looking up an order, searching products), you MUST call the appropriate tool instead of refusing.\n'
+                  + '4. Only say you don\'t have information if no tool can help either.\n'
+                  + '5. Keep your response short and honest.\n\n---\n\n'
+                : '3. You MUST politely tell the customer you do not have information on this topic.\n'
+                  + '4. You MAY suggest they contact support or rephrase their question.\n'
+                  + '5. Keep your response short and honest.\n\n---\n\n');
+            systemMessage = noKbOverride + systemMessage;
+          }
+        } catch (kbError) {
+          console.warn('[Operor] ⚠️  KB retrieval failed:', (kbError as Error).message);
+        }
+      }
+
+      // If the user's message contains a URL and we have fetch tools, hint the LLM to use them
+      const userText = context.currentMessage.text;
+      const urlPattern = /https?:\/\/[^\s]+/i;
+      if (urlPattern.test(userText) && allTools.length > 0) {
+        const fetchToolNames = allTools
+          .filter((t: any) => /crawl|fetch|scrape|browse/i.test(t.name))
+          .map((t: any) => t.name);
+        if (fetchToolNames.length > 0) {
+          systemMessage += `\n\n## URL Detected\n\nThe user's message contains a URL. You MUST use one of your tools (${fetchToolNames.join(', ')}) to fetch the page content before responding. Do NOT say you cannot access URLs — you have tools that can fetch web pages.`;
+        }
+      }
+
+      // Inject prompt skill instructions LAST — highest priority position in the system prompt.
+      // This ensures skill directives override KB FAQ answers and all other context.
+      if (options?.promptSkills?.length) {
+        systemMessage += '\n\n## Skill Instructions (HIGHEST PRIORITY)\n\n'
+          + 'The following skill instructions are the HIGHEST PRIORITY directives for this agent.\n'
+          + 'They OVERRIDE any conflicting guidance above, including FAQ answers and Knowledge Base context.\n'
+          + 'You MUST follow these instructions even if they contradict KB or FAQ content.\n\n'
+          + options.promptSkills.map(s => `### ${s.name}\n\n${s.content}`).join('\n\n---\n\n');
+      }
+
+      const messages: Array<{ role: string; content: string }> = [
+        { role: 'system', content: systemMessage },
+        ...context.history.map((m: any) => ({
+          role: m.role as 'user' | 'assistant',
+          content: m.content,
+        })),
+        { role: 'user', content: context.currentMessage.text },
+      ];
+
+      const toolCalls: any[] = [];
+      let finalText = '';
+      let iterations = 0;
+      const maxIterations = 5;
+      const mediaAttachments: Array<{ buffer: Buffer; fileName: string; mimeType: string }> = [];
+
+      // Accumulate token usage across multi-turn tool calling loop
+      let totalPromptTokens = 0;
+      let totalCompletionTokens = 0;
+
+      while (iterations < maxIterations) {
+        iterations++;
+
+        const llmStart = Date.now();
+        console.log(`[Operor] 💭 LLM call #${iterations} (${allTools.length} tools available)...`);
+        const response = await llm.complete(messages, {
+          tools: allTools.map((t: any) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+          })),
+        });
+        console.log(`[Operor] 💭 LLM responded in ${((Date.now() - llmStart) / 1000).toFixed(1)}s${response.toolCalls?.length ? ` → ${response.toolCalls.length} tool call(s): ${response.toolCalls.map((tc: any) => tc.name).join(', ')}` : ' → text response'}`);
+
+        // Accumulate usage from each LLM call
+        if (response.usage) {
+          totalPromptTokens += response.usage.promptTokens || 0;
+          totalCompletionTokens += response.usage.completionTokens || 0;
+        }
+
+        if (response.toolCalls && response.toolCalls.length > 0) {
+          const executedTools: Array<{ name: string; result: any; success: boolean; error?: string }> = [];
+
+          for (const tc of response.toolCalls) {
+            const tool = allTools.find((t: any) => t.name === tc.name);
+            if (!tool) continue;
+            const toolStart = Date.now();
+            console.log(`[Operor] 🔧 Executing tool: ${tc.name}${tc.arguments?.url ? ` (${tc.arguments.url})` : ''}...`);
+            try {
+              const rawResult = await tool.execute(tc.arguments);
+              const { cleanResult, media } = extractMediaFromToolResult(rawResult);
+              if (media) {
+                mediaAttachments.push(media);
+                console.log(`[Operor] 🖼️  Extracted ${media.mimeType} (${media.buffer.length} bytes) from tool ${tc.name}`);
+              }
+
+              // If a crawl4ai tool returned empty content, retry with fetchContent (same path as /learn-url)
+              const fallbackResult = await retryCrawlWithFetchContent(tc.name, tc.arguments, cleanResult);
+              const finalResult = fallbackResult ?? cleanResult;
+
+              const duration = Date.now() - toolStart;
+              console.log(`[Operor] 🔧 Tool ${tc.name} completed in ${(duration / 1000).toFixed(1)}s${fallbackResult ? ' (via fetchContent fallback)' : ''}`);
+              toolCalls.push({ id: tc.id, name: tc.name, params: tc.arguments, result: finalResult, success: true, duration });
+              executedTools.push({ name: tc.name, result: finalResult, success: true });
+            } catch (err: any) {
+              const duration = Date.now() - toolStart;
+              console.log(`[Operor] 🔧 Tool ${tc.name} failed after ${(duration / 1000).toFixed(1)}s, attempting fallback...`);
+              const errorMsg = err.message || err.toString?.() || 'Unknown tool error';
+
+              // If a crawl4ai tool threw (e.g. empty result treated as error), try fetchContent fallback
+              const catchFallback = await retryCrawlWithFetchContent(tc.name, tc.arguments, null);
+              if (catchFallback) {
+                toolCalls.push({ id: tc.id, name: tc.name, params: tc.arguments, result: catchFallback, success: true, duration });
+                executedTools.push({ name: tc.name, result: catchFallback, success: true });
+              } else {
+                toolCalls.push({ id: tc.id, name: tc.name, params: tc.arguments, result: null, success: false, error: errorMsg, duration });
+                executedTools.push({ name: tc.name, result: null, success: false, error: errorMsg });
+              }
+            }
+          }
+
+          const toolResultSummary = executedTools.map(tc =>
+            `[Tool ${tc.name}]: ${JSON.stringify(tc.success ? tc.result : { error: tc.error })}`
+          ).join('\n');
+
+          messages.push(
+            { role: 'assistant', content: `I'll call ${executedTools.map(tc => tc.name).join(', ')} to help with that.` },
+            { role: 'user', content: `Tool results:\n${toolResultSummary}\n\nPlease use these results to respond to the customer.` }
+          );
+        } else {
+          finalText = response.text;
+          break;
+        }
+      }
+
+      const modelName = llm.getModelName?.() || llm.config?.model || '';
+      const cost = estimateCost(totalPromptTokens, totalCompletionTokens, modelName);
+
+      // Attach the first extracted media (e.g. screenshot) to the response
+      const media = mediaAttachments[0];
+
+      return {
+        text: finalText,
+        toolCalls,
+        duration: Date.now() - startTime,
+        cost: cost > 0 ? cost : undefined,
+        usage: { promptTokens: totalPromptTokens, completionTokens: totalCompletionTokens },
+        metadata: kbMetadata,
+        ...(media && {
+          mediaBuffer: media.buffer,
+          mediaFileName: media.fileName,
+          mediaMimeType: media.mimeType,
+        }),
+      };
+    } catch (processError: any) {
+      const msg = processError.message || '';
+      const code = processError.code || '';
+      let errorMessage = 'Sorry, something went wrong. Please try again.';
+
+      if (msg.includes('ECONNREFUSED') || msg.includes('ETIMEDOUT') || msg.includes('ENOTFOUND') ||
+          msg.includes('fetch failed') || code === 'ECONNREFUSED' || code === 'ETIMEDOUT' ||
+          code === 'UND_ERR_CONNECT_TIMEOUT') {
+        errorMessage = 'Cannot connect to LLM API. Check your network connection and LLM_API_KEY.';
+      } else if (msg.includes('401') || msg.includes('403') || msg.includes('Unauthorized') ||
+                 msg.includes('Incorrect API key') || msg.includes('API key')) {
+        errorMessage = 'LLM API authentication failed. Check your LLM_API_KEY in .env';
+      } else if (msg.includes('429') || msg.includes('rate limit')) {
+        errorMessage = 'LLM API rate limit exceeded. Please try again later.';
+      } else if (msg) {
+        errorMessage = `LLM error: ${msg}`;
+      }
+
+      return { text: errorMessage, toolCalls: [], duration: Date.now() - startTime };
+    }
+  };
+}

package/src/commands/reset.ts

@@ -0,0 +1,72 @@
+import { existsSync, unlinkSync, rmSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { readConfig } from '../config.js';
+
+function fileSize(p: string): string {
+  try {
+    const s = statSync(p).size;
+    if (s < 1024) return `${s} B`;
+    if (s < 1024 * 1024) return `${(s / 1024).toFixed(1)} KB`;
+    return `${(s / (1024 * 1024)).toFixed(1)} MB`;
+  } catch { return '?'; }
+}
+
+export async function runReset(opts: { yes?: boolean; keepConfig?: boolean }) {
+  const config = readConfig();
+  const cwd = process.cwd();
+
+  const targets: { label: string; path: string; isDir?: boolean }[] = [
+    { label: 'Memory DB', path: resolve(cwd, config.MEMORY_DB_PATH || './operor.db') },
+    { label: 'Knowledge Base DB', path: resolve(cwd, config.KB_DB_PATH || './knowledge.db') },
+    { label: 'Copilot DB', path: resolve(cwd, config.COPILOT_DB_PATH || './copilot.db') },
+    { label: 'Analytics DB', path: resolve(cwd, config.ANALYTICS_DB_PATH || './analytics.db') },
+  ];
+
+  if (!opts.keepConfig) {
+    targets.push({ label: 'MCP skills config', path: resolve(cwd, 'mcp.json') });
+  }
+
+  targets.push({ label: 'Baileys auth state', path: resolve(cwd, 'baileys_auth'), isDir: true });
+
+  const found = targets.filter(t => existsSync(t.path));
+
+  if (found.length === 0) {
+    console.log('Nothing to reset — no data files found.');
+    return;
+  }
+
+  console.log('\nThe following will be deleted:\n');
+  for (const t of found) {
+    const size = t.isDir ? 'dir' : fileSize(t.path);
+    console.log(`  ${t.label.padEnd(22)} ${t.path} (${size})`);
+  }
+  console.log('');
+
+  if (!opts.yes) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise<string>(r => rl.question('Type "yes" to confirm: ', r));
+    rl.close();
+    if (answer.trim().toLowerCase() !== 'yes') {
+      console.log('Aborted.');
+      return;
+    }
+  }
+
+  let deleted = 0;
+  for (const t of found) {
+    try {
+      if (t.isDir) {
+        rmSync(t.path, { recursive: true, force: true });
+      } else {
+        unlinkSync(t.path);
+      }
+      console.log(`  Deleted: ${t.label}`);
+      deleted++;
+    } catch (err: any) {
+      console.error(`  Failed: ${t.label} — ${err.message}`);
+    }
+  }
+
+  console.log(`\nReset complete. ${deleted}/${found.length} items deleted.`);
+}