fraude-code 0.1.0

package/src/services/embeddingService.ts

@@ -0,0 +1,229 @@
+import { pipeline, type FeatureExtractionPipeline } from "@xenova/transformers";
+import { connect, type Connection, type Table } from "@lancedb/lancedb";
+import path from "path";
+
+// ============================================================================
+// Embedding Service - Local embeddings with transformers.js + LanceDB storage
+// ============================================================================
+
+class EmbeddingService {
+  private static instance: EmbeddingService;
+  private extractor: FeatureExtractionPipeline | null = null;
+  private db: Connection | null = null;
+  private table: Table | null = null;
+  private initPromise: Promise<void> | null = null;
+
+  // Model: all-MiniLM-L6-v2 produces 384-dim embeddings
+  private static MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+  private static TABLE_NAME = "facts";
+
+  private constructor() {}
+
+  static getInstance(): EmbeddingService {
+    if (!EmbeddingService.instance) {
+      EmbeddingService.instance = new EmbeddingService();
+    }
+    return EmbeddingService.instance;
+  }
+
+  async init(): Promise<void> {
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this.doInit();
+    return this.initPromise;
+  }
+
+  private async doInit(): Promise<void> {
+    // Initialize transformers.js pipeline
+    this.extractor = await pipeline(
+      "feature-extraction",
+      EmbeddingService.MODEL_ID,
+      {
+        // Use ONNX runtime for Bun compatibility
+        revision: "main",
+      },
+    );
+
+    // Initialize LanceDB
+    const dbPath = path.join(process.cwd(), ".fraude", "lancedb");
+    this.db = await connect(dbPath);
+
+    // Try to open existing table, or we'll create on first insert
+    try {
+      this.table = await this.db.openTable(EmbeddingService.TABLE_NAME);
+    } catch {
+      // Table doesn't exist yet, will create on first insert
+      this.table = null;
+    }
+  }
+
+  /**
+   * Generate embedding for text
+   */
+  async embed(text: string): Promise<number[]> {
+    await this.init();
+    if (!this.extractor) throw new Error("Extractor not initialized");
+
+    const output = await this.extractor(text, {
+      pooling: "mean",
+      normalize: true,
+    });
+
+    // Convert to regular array
+    return Array.from(output.data as Float32Array);
+  }
+
+  /**
+   * Store a fact with its embedding
+   */
+  async store(fact: {
+    id: string;
+    type: string;
+    content: string;
+    data?: string;
+    timestamp: number;
+    sessionId: string;
+    confidence: number;
+  }): Promise<void> {
+    await this.init();
+    if (!this.db) throw new Error("Database not initialized");
+
+    const embedding = await this.embed(fact.content);
+
+    const record = {
+      id: fact.id,
+      type: fact.type,
+      content: fact.content,
+      data: fact.data || "",
+      timestamp: fact.timestamp,
+      sessionId: fact.sessionId,
+      confidence: fact.confidence,
+      vector: embedding,
+    };
+
+    if (!this.table) {
+      // Create table with first record
+      this.table = await this.db.createTable(EmbeddingService.TABLE_NAME, [
+        record,
+      ]);
+    } else {
+      // Upsert: delete existing record with same ID before adding
+      try {
+        await this.table.delete(`id = '${fact.id}'`);
+      } catch {
+        // Record might not exist, continue with insert
+      }
+      await this.table.add([record]);
+    }
+  }
+
+  /**
+   * Search for similar facts using vector similarity
+   */
+  async search(
+    query: string,
+    limit: number = 5,
+    threshold: number = 0.5,
+  ): Promise<
+    Array<{
+      id: string;
+      type: string;
+      content: string;
+      data: string;
+      timestamp: number;
+      sessionId: string;
+      confidence: number;
+      score: number;
+    }>
+  > {
+    await this.init();
+    if (!this.table) return [];
+
+    const queryEmbedding = await this.embed(query);
+
+    const results = await this.table
+      .search(queryEmbedding)
+      .limit(limit)
+      .toArray();
+
+    // Filter by threshold and map results
+    return results
+      .filter((r) => {
+        // LanceDB returns _distance (lower is better) or _relevance (higher is better)
+        const score = 1 - (r._distance || 0);
+        return score >= threshold;
+      })
+      .map((r) => ({
+        id: r.id as string,
+        type: r.type as string,
+        content: r.content as string,
+        data: r.data as string,
+        timestamp: r.timestamp as number,
+        sessionId: r.sessionId as string,
+        confidence: r.confidence as number,
+        score: 1 - (r._distance || 0),
+      }));
+  }
+
+  /**
+   * Delete a fact by ID
+   */
+  async delete(id: string): Promise<void> {
+    await this.init();
+    if (!this.table) return;
+
+    await this.table.delete(`id = '${id}'`);
+  }
+
+  /**
+   * Clear all data (drops table)
+   */
+  async clear(): Promise<void> {
+    await this.init();
+    if (!this.db) return;
+
+    try {
+      await this.db.dropTable(EmbeddingService.TABLE_NAME);
+      this.table = null;
+    } catch {
+      // Table might not exist
+    }
+  }
+
+  /**
+   * Get all facts (for migration/debugging)
+   */
+  async getAll(): Promise<
+    Array<{
+      id: string;
+      type: string;
+      content: string;
+      data: string;
+      timestamp: number;
+    }>
+  > {
+    await this.init();
+    if (!this.table) return [];
+
+    const results = await this.table.query().toArray();
+    return results.map((r) => ({
+      id: r.id as string,
+      type: r.type as string,
+      content: r.content as string,
+      data: r.data as string,
+      timestamp: r.timestamp as number,
+    }));
+  }
+
+  /**
+   * Close connections
+   */
+  async close(): Promise<void> {
+    // LanceDB doesn't require explicit close, but reset state
+    this.table = null;
+    this.db = null;
+    this.extractor = null;
+    this.initPromise = null;
+  }
+}
+
+export default EmbeddingService;

package/src/services/google.ts

@@ -0,0 +1,65 @@
+import { UpdateSettings } from "@/config/settings";
+import useSettingsStore from "../store/useSettingsStore";
+import type { Model } from "../types/Model";
+
+const getSettings = () => useSettingsStore.getState();
+
+class GoogleClient {
+  async syncGoogleModels() {
+    if (!getSettings().google_api_key && !process.env.GOOGLE_API_KEY) {
+      return;
+    }
+    const savedModels = getSettings().models;
+    const existingGoogleModels = savedModels.filter((m) => m.type === "google");
+    const otherModels = savedModels.filter((m) => m.type !== "google");
+
+    const models: Model[] = [
+      {
+        type: "google",
+        name: "gemini-3-flash-preview",
+        modified_at: new Date().toISOString(),
+        digest: "",
+        usage: {
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0,
+        },
+        details: {
+          provider: "google",
+          context_length: 100000,
+        },
+      } as Model,
+      {
+        type: "google",
+        name: "gemini-2.5-flash-lite",
+        modified_at: new Date().toISOString(),
+        digest: "",
+        usage: {
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0,
+        },
+        details: {
+          provider: "google",
+          context_length: 100000,
+        },
+      } as Model,
+    ].map((model) => {
+      const existing = existingGoogleModels.find((m) => m.name === model.name);
+      if (existing) {
+        return {
+          ...model,
+          digest: existing.digest || "",
+          usage: existing.usage || model.usage,
+          details: { ...model.details, ...existing.details },
+        };
+      }
+      return model;
+    });
+
+    const mergedModels = [...otherModels, ...models];
+    await UpdateSettings({ models: mergedModels });
+  }
+}
+
+export default new GoogleClient();

package/src/services/graphSerializer.ts

@@ -0,0 +1,248 @@
+/**
+ * GraphSerializer - Optimized serialization of knowledge graph subsets for LLM context.
+ *
+ * Converts graph data into concise, LLM-friendly markdown format that maximizes
+ * information density while staying within context window limits.
+ */
+
+import type { Fact } from "@/utils/agentCognition";
+import path from "path";
+
+export interface SerializationOptions {
+  maxSymbols?: number;
+  maxDecisions?: number;
+  maxFacts?: number;
+  includeRelations?: boolean;
+  format?: "markdown" | "compact";
+}
+
+const DEFAULT_OPTIONS: SerializationOptions = {
+  maxSymbols: 10,
+  maxDecisions: 5,
+  maxFacts: 5,
+  includeRelations: true,
+  format: "markdown",
+};
+
+export class GraphSerializer {
+  /**
+   * Serialize a collection of facts into LLM-friendly context.
+   */
+  static serialize(
+    facts: Fact[],
+    relations?: Array<{ source: string; target: string; type: string }>,
+    options: SerializationOptions = {},
+  ): string {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+
+    if (opts.format === "compact") {
+      return GraphSerializer.serializeCompact(facts, relations, opts);
+    }
+
+    return GraphSerializer.serializeMarkdown(facts, relations, opts);
+  }
+
+  /**
+   * Markdown format - human-readable, good for general context.
+   */
+  private static serializeMarkdown(
+    facts: Fact[],
+    relations?: Array<{ source: string; target: string; type: string }>,
+    opts: SerializationOptions = DEFAULT_OPTIONS,
+  ): string {
+    if (facts.length === 0) return "";
+
+    const parts: string[] = [];
+
+    // Group facts by type
+    const byType = GraphSerializer.groupByType(facts);
+
+    // Code entities (new types: file, module, function, class, interface, variable, symbol)
+    const codeTypes = [
+      "file",
+      "module",
+      "function",
+      "class",
+      "interface",
+      "variable",
+      "symbol",
+      "concept",
+    ];
+    const codeEntities = facts.filter((f) => codeTypes.includes(f.type));
+    if (codeEntities.length > 0) {
+      parts.push("## Code Context\n");
+
+      // Group by file
+      const byFile = new Map<string, Fact[]>();
+      for (const c of codeEntities.slice(0, opts.maxSymbols!)) {
+        const file = (c.data?.file as string) || "unknown";
+        const list = byFile.get(file) || [];
+        list.push(c);
+        byFile.set(file, list);
+      }
+
+      for (const [file, symbols] of byFile) {
+        const fileName = path.basename(file);
+        parts.push(`### ${fileName}\n`);
+        for (const sym of symbols) {
+          const sig = sym.data?.signature ? ` ${sym.data.signature}` : "";
+          const exp = sym.data?.exported ? "export " : "";
+          parts.push(
+            `- \`${exp}${sym.data?.kind || "Symbol"}: ${sym.data?.symbol}${sig}\``,
+          );
+          if (sym.data?.docstring) {
+            const doc = (sym.data.docstring as string).slice(0, 80);
+            parts.push(`  - ${doc}${doc.length >= 80 ? "..." : ""}`);
+          }
+        }
+        parts.push("");
+      }
+    }
+
+    // Decisions
+    const decisions = byType.get("decision") || [];
+    if (decisions.length > 0) {
+      parts.push("## Project Decisions\n");
+      for (const d of decisions.slice(0, opts.maxDecisions!)) {
+        parts.push(`- ${d.content}`);
+      }
+      parts.push("");
+    }
+
+    // Facts
+    const factItems = byType.get("fact") || [];
+    if (factItems.length > 0) {
+      parts.push("## Known Facts\n");
+      for (const f of factItems.slice(0, opts.maxFacts!)) {
+        parts.push(`- ${f.content}`);
+      }
+      parts.push("");
+    }
+
+    // Relations (optional)
+    if (opts.includeRelations && relations && relations.length > 0) {
+      parts.push("## Relationships\n");
+      const relationsByType = new Map<string, number>();
+      for (const r of relations) {
+        relationsByType.set(r.type, (relationsByType.get(r.type) || 0) + 1);
+      }
+      for (const [type, count] of relationsByType) {
+        parts.push(`- ${type}: ${count} connections`);
+      }
+      parts.push("");
+    }
+
+    return parts.join("\n").trim();
+  }
+
+  /**
+   * Compact format - minimal tokens, maximum information density.
+   */
+  private static serializeCompact(
+    facts: Fact[],
+    relations?: Array<{ source: string; target: string; type: string }>,
+    opts: SerializationOptions = DEFAULT_OPTIONS,
+  ): string {
+    if (facts.length === 0) return "";
+
+    const lines: string[] = [];
+    const byType = GraphSerializer.groupByType(facts);
+
+    // Code entities
+    const codeTypes = [
+      "file",
+      "module",
+      "function",
+      "class",
+      "interface",
+      "variable",
+      "symbol",
+      "concept",
+    ];
+    const codeEntities = facts.filter((f) => codeTypes.includes(f.type));
+    if (codeEntities.length > 0) {
+      lines.push("[code]");
+      for (const c of codeEntities.slice(0, opts.maxSymbols!)) {
+        const kind =
+          (c.data?.kind as string)?.charAt(0) || c.type.charAt(0).toUpperCase();
+        const name = c.data?.symbol || "?";
+        const sig = c.data?.signature || "";
+        const file = c.data?.file
+          ? `@${path.basename(c.data.file as string)}`
+          : "";
+        lines.push(`${kind}:${name}${sig}${file}`);
+      }
+    }
+
+    // Decisions: brief
+    const decisions = byType.get("decision") || [];
+    if (decisions.length > 0) {
+      lines.push("[dec]");
+      for (const d of decisions.slice(0, opts.maxDecisions!)) {
+        lines.push(d.content.slice(0, 100));
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Create a focused context for a specific file.
+   */
+  static serializeFileContext(
+    filePath: string,
+    symbols: Fact[],
+    relatedFacts: Fact[],
+  ): string {
+    const parts: string[] = [
+      `## File: ${path.basename(filePath)}\n`,
+      `Path: \`${filePath}\`\n`,
+    ];
+
+    if (symbols.length > 0) {
+      parts.push("### Symbols\n");
+      for (const sym of symbols) {
+        const sig = sym.data?.signature ? `: ${sym.data.signature}` : "";
+        parts.push(`- **${sym.data?.kind}** \`${sym.data?.symbol}\`${sig}`);
+      }
+      parts.push("");
+    }
+
+    if (relatedFacts.length > 0) {
+      parts.push("### Related Knowledge\n");
+      for (const f of relatedFacts.slice(0, 5)) {
+        parts.push(`- [${f.type}] ${f.content}`);
+      }
+    }
+
+    return parts.join("\n").trim();
+  }
+
+  /**
+   * Create summary statistics for a graph subset.
+   */
+  static summarize(
+    facts: Fact[],
+    relations?: Array<{ source: string; target: string; type: string }>,
+  ): string {
+    const byType = GraphSerializer.groupByType(facts);
+    const counts = Array.from(byType.entries())
+      .map(([type, list]) => `${type}:${list.length}`)
+      .join(" ");
+
+    const relCount = relations?.length || 0;
+    return `[${facts.length} facts (${counts}), ${relCount} relations]`;
+  }
+
+  private static groupByType(facts: Fact[]): Map<string, Fact[]> {
+    const byType = new Map<string, Fact[]>();
+    for (const fact of facts) {
+      const list = byType.get(fact.type) || [];
+      list.push(fact);
+      byType.set(fact.type, list);
+    }
+    return byType;
+  }
+}
+
+export default GraphSerializer;

package/src/services/groq.ts

@@ -0,0 +1,23 @@
+import useSettingsStore from "../store/useSettingsStore";
+
+const getSettings = () => useSettingsStore.getState();
+
+class GroqClient {
+  async getModelData(model: string) {
+    const url = `https://api.groq.com/openai/v1/models/${model}`;
+    const options = {
+      method: "GET",
+      headers: { Authorization: `Bearer ${getSettings().groq_api_key}` },
+    };
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch Groq model ${model}: ${response.status}`
+      );
+    }
+    const data: any = await response.json();
+    return data;
+  }
+}
+
+export default new GroqClient();