fraude-code 0.1.0

package/src/services/symbolExtractor.ts

@@ -0,0 +1,277 @@
+import { getLSPClient } from "@/utils/lspClient";
+import type { Fact } from "@/utils/agentCognition";
+import fs from "fs";
+import path from "path";
+
+/**
+ * Map LSP symbol kinds to specific graph node types.
+ */
+function kindToType(kind: string): Fact["type"] {
+  const map: Record<string, Fact["type"]> = {
+    Function: "function",
+    Class: "class",
+    Interface: "interface",
+    Variable: "variable",
+    Method: "function",
+    Property: "variable",
+    Struct: "class",
+    Enum: "class",
+    Trait: "interface",
+  };
+  return map[kind] || "symbol";
+}
+
+interface SymbolRelation {
+  source: string; // Symbol name
+  target: string; // Symbol name
+  type: "CALLS" | "DEFINES" | "INHERITS" | "IMPORTS";
+  weight: number;
+}
+
+export class SymbolExtractor {
+  private lsp = getLSPClient();
+
+  /**
+   * Resolve an import module to a file path.
+   * Handles relative imports and attempts common resolutions.
+   */
+  private resolveImport(
+    fromFile: string,
+    module: string,
+    isRelative: boolean,
+  ): string | null {
+    const dir = path.dirname(fromFile);
+    const ext = fromFile.split(".").pop() || "";
+
+    if (isRelative) {
+      // Relative import - try common extensions
+      const extensions =
+        ext === "py" ? [".py"] : [".ts", ".tsx", ".js", ".jsx"];
+      const basePath = path.resolve(dir, module.replace(/\./g, "/"));
+
+      for (const extTry of extensions) {
+        const candidate = basePath + extTry;
+        if (fs.existsSync(candidate)) {
+          return candidate;
+        }
+        // Try as directory with index
+        const indexCandidate = path.join(basePath, `index${extTry}`);
+        if (fs.existsSync(indexCandidate)) {
+          return indexCandidate;
+        }
+      }
+    }
+
+    // Return module name for external imports (can be linked later)
+    return null;
+  }
+
+  async analyze(filePath: string): Promise<{
+    facts: Omit<Fact, "id" | "timestamp" | "sessionId">[];
+    relations: { sourceIdx: number; targetIdx: number; type: string }[];
+  }> {
+    if (!fs.existsSync(filePath)) return { facts: [], relations: [] };
+
+    // Standardize on relative paths for the graph
+    const relativePath = path.relative(process.cwd(), filePath);
+    const content = fs.readFileSync(filePath, "utf-8");
+
+    // Get symbols with detail - this now includes children
+    const symbols = await this.lsp.getDocumentSymbolsWithDetails(
+      filePath,
+      content,
+    );
+
+    const facts: Omit<Fact, "id" | "timestamp" | "sessionId">[] = [];
+    const relations: { sourceIdx: number; targetIdx: number; type: string }[] =
+      [];
+
+    // Track symbol facts to link relations
+    const symbolToIdx = new Map<string, number>();
+    const filePathToIdx = new Map<string, number>();
+
+    // 1. Create a fact for the file itself using RELATIVE path
+    const fileFact: Omit<Fact, "id" | "timestamp" | "sessionId"> = {
+      type: "file",
+      content: `File: ${relativePath}`,
+      data: { file: relativePath },
+      confidence: 1.0,
+      validated: Date.now(),
+    };
+    facts.push(fileFact);
+    const fileIdx = 0;
+    filePathToIdx.set(relativePath, fileIdx);
+
+    // 2. Process imports -> IMPORTS relations
+    const imports = await this.lsp.getImports(filePath, content);
+    for (const imp of imports) {
+      const resolvedAbsPath = this.resolveImport(
+        filePath,
+        imp.module,
+        imp.isRelative,
+      );
+
+      const resolvedPath = resolvedAbsPath
+        ? path.relative(process.cwd(), resolvedAbsPath)
+        : null;
+
+      // Create a fact for the imported module
+      const importFact: Omit<Fact, "id" | "timestamp" | "sessionId"> = {
+        type: "module",
+        content: `Module: ${imp.alias || imp.module}`,
+        data: {
+          file: resolvedPath || imp.module,
+          module: imp.module,
+          alias: imp.alias,
+          isExternal: !resolvedPath,
+        },
+        confidence: resolvedPath ? 1.0 : 0.7,
+        validated: Date.now(),
+      };
+      facts.push(importFact);
+      const importIdx = facts.length - 1;
+
+      relations.push({
+        sourceIdx: fileIdx,
+        targetIdx: importIdx,
+        type: "IMPORTS",
+      });
+    }
+
+    // 3. Process symbols recursively
+    const processSymbol = (sym: any, parentIdx: number) => {
+      // Build rich content string for LLM consumption
+      let content = `${sym.kind}: ${sym.name} (${relativePath})`;
+      if (sym.signature) {
+        content += ` ${sym.signature}`;
+      }
+      if (sym.docstring) {
+        content += ` - ${sym.docstring.slice(0, 150)}`;
+      }
+
+      // Create symbol fact with enhanced data
+      const fact: Omit<Fact, "id" | "timestamp" | "sessionId"> = {
+        type: kindToType(sym.kind),
+        content,
+        data: {
+          file: relativePath,
+          symbol: sym.name,
+          kind: sym.kind,
+          type: kindToType(sym.kind),
+          line: sym.line,
+          signature: sym.signature,
+          docstring: sym.docstring,
+          exported: sym.exported,
+        },
+        confidence: 1.0,
+        validated: Date.now(),
+      };
+
+      facts.push(fact);
+      const symIdx = facts.length - 1;
+      symbolToIdx.set(sym.name, symIdx); // Note: Flat map might clash if same name used in nested scopes effectively, but ok for now
+
+      // Link: Parent DEFINES/CONTAINS Symbol
+      relations.push({
+        sourceIdx: parentIdx,
+        targetIdx: symIdx,
+        type: parentIdx === fileIdx ? "DEFINES" : "CONTAINS",
+      });
+
+      // Inherits relation if applicable (class extension)
+      // Note: LSP usually gives inheritance at top level, but if nested classes existed...
+
+      // Recurse for children
+      if (sym.children && sym.children.length > 0) {
+        for (const child of sym.children) {
+          processSymbol(child, symIdx);
+        }
+      }
+    };
+
+    for (const sym of symbols) {
+      processSymbol(sym, fileIdx);
+    }
+
+    // 4. Extract inheritance -> INHERITS relations
+    const inheritance = await this.lsp.getInheritance(filePath, content);
+    for (const inh of inheritance) {
+      const childIdx = symbolToIdx.get(inh.className);
+      let parentIdx = symbolToIdx.get(inh.parentName);
+
+      if (!parentIdx) {
+        // Parent is external - create a symbol fact
+        const parentFact: Omit<Fact, "id" | "timestamp" | "sessionId"> = {
+          type: "class",
+          content: `Class: ${inh.parentName}`,
+          data: { symbol: inh.parentName, kind: "Class" },
+          confidence: 0.8,
+          validated: Date.now(),
+        };
+        facts.push(parentFact);
+        parentIdx = facts.length - 1;
+        symbolToIdx.set(inh.parentName, parentIdx);
+      }
+
+      if (childIdx !== undefined) {
+        relations.push({
+          sourceIdx: childIdx,
+          targetIdx: parentIdx,
+          type: "INHERITS",
+        });
+      }
+    }
+
+    // 5. Extract calls with source context -> CALLS relations
+    // Get all calls from the file
+    const allCalls = await this.lsp.getOutgoingCalls(filePath, content, 1, 1);
+
+    // Group calls by sourceContext and deduplicate
+    const processedCalls = new Set<string>();
+    for (const call of allCalls) {
+      const callKey = `${call.sourceContext || ""}:${call.name}`;
+      if (processedCalls.has(callKey)) continue;
+      processedCalls.add(callKey);
+
+      // Find or create target fact
+      let targetIdx = symbolToIdx.get(call.name);
+      if (targetIdx === undefined) {
+        // External call - create a weak symbol fact
+        const targetFact: Omit<Fact, "id" | "timestamp" | "sessionId"> = {
+          type: "symbol",
+          content: `Symbol: ${call.name}`,
+          data: {
+            file: call.file
+              ? path.relative(process.cwd(), call.file)
+              : undefined,
+            symbol: call.name,
+          },
+          confidence: 0.8,
+          validated: Date.now(),
+        };
+        facts.push(targetFact);
+        targetIdx = facts.length - 1;
+        symbolToIdx.set(call.name, targetIdx);
+      }
+
+      // Find source (calling function)
+      let sourceIdx: number | undefined;
+      if (call.sourceContext) {
+        sourceIdx = symbolToIdx.get(call.sourceContext);
+      }
+      if (sourceIdx === undefined) {
+        sourceIdx = fileIdx; // Top-level call, link from file
+      }
+
+      relations.push({
+        sourceIdx,
+        targetIdx,
+        type: "CALLS",
+      });
+    }
+
+    return { facts, relations };
+  }
+}
+
+export default SymbolExtractor;

package/src/store/useFraudeStore.ts

@@ -0,0 +1,123 @@
+import { create } from "zustand";
+import type { OutputItem, OutputItemType } from "@/types/OutputItem";
+import ContextManager from "@/agent/contextManager";
+import log from "@/utils/logger";
+
+interface ModelSelectionRequest {
+  originalModel: string;
+  errorMessage: string;
+  resolve: (modelName: string | null) => void;
+}
+
+interface FraudeStore {
+  executionMode: 0 | 1 | 2; // 0 = Fast, 1 = Plan, 2 = Ask
+  outputItems: OutputItem[];
+  started: boolean;
+  status: number; // 0 = idle, 1 = running, 2 = waiting, 3 = reviewing changes, 4 = awaiting model selection, -1 = interrupted
+  elapsedTime: number;
+  lastBreak: number;
+  statusText?: string;
+  contextManager: ContextManager;
+  researchCache?: Record<string, string>;
+  abortController: AbortController | null;
+  pendingModelSelection: ModelSelectionRequest | null;
+  interruptAgent: () => void;
+  updateOutput: (
+    type: OutputItemType,
+    content: string,
+    config?: {
+      duration?: number;
+      dontOverride?: boolean;
+    },
+  ) => void;
+  requestModelSelection: (
+    originalModel: string,
+    errorMessage: string,
+  ) => Promise<string | null>;
+  resolveModelSelection: (modelName: string | null) => void;
+}
+
+const useFraudeStore = create<FraudeStore>((set, get) => ({
+  executionMode: 0 as 0 | 1 | 2,
+  outputItems: [],
+  started: false,
+  status: 0,
+  elapsedTime: 0,
+  lastBreak: 0,
+  statusText: "",
+  contextManager: new ContextManager(),
+  researchCache: undefined,
+  abortController: null,
+  pendingModelSelection: null,
+  interruptAgent: () => {
+    const controller = get().abortController;
+    if (controller && !controller.signal.aborted) {
+      try {
+        controller.abort();
+      } catch (e) {
+        log(`Abort caught: ${e}`);
+      }
+    }
+  },
+  updateOutput: (type, rawContent, config) => {
+    set((state) => {
+      const outputItems = [...state.outputItems];
+      const latestOutput = outputItems[outputItems.length - 1];
+      const dontOverrideType = new Set(["log", "interrupted", "command"]);
+      let content = rawContent.replaceAll(process.cwd(), "@");
+      if (
+        latestOutput &&
+        latestOutput.type === type &&
+        !dontOverrideType.has(type) &&
+        !config?.dontOverride
+      ) {
+        outputItems[outputItems.length - 1] = {
+          ...latestOutput,
+          content,
+          duration: config?.duration,
+        };
+      } else {
+        outputItems.push({
+          id: crypto.randomUUID(),
+          type,
+          content,
+          duration: config?.duration,
+        });
+      }
+      return {
+        outputItems,
+      };
+    });
+  },
+  requestModelSelection: (originalModel: string, errorMessage: string) => {
+    return new Promise<string | null>((resolve) => {
+      set({
+        status: 4, // awaiting model selection
+        statusText: "Awaiting model selection...",
+        pendingModelSelection: {
+          originalModel,
+          errorMessage,
+          resolve,
+        },
+      });
+      // Also add to output items so it renders
+      get().updateOutput(
+        "modelSelect",
+        JSON.stringify({ originalModel, errorMessage }),
+      );
+    });
+  },
+  resolveModelSelection: (modelName: string | null) => {
+    const pending = get().pendingModelSelection;
+    if (pending) {
+      pending.resolve(modelName);
+      set({
+        status: modelName ? 1 : 0, // back to running or idle
+        statusText: modelName ? "Retrying with new model..." : "",
+        pendingModelSelection: null,
+      });
+    }
+  },
+}));
+
+export default useFraudeStore;

package/src/store/useSettingsStore.ts

@@ -0,0 +1,38 @@
+import { create } from "zustand";
+import { Settings, UpdateSettings } from "../config/settings";
+import { SettingsSchema, type Config } from "../config/schema";
+
+interface SettingsActions {
+  setOllamaUrl: (url: string) => void;
+  syncWithSettings: () => void;
+}
+
+type SettingsState = Config & SettingsActions;
+
+const DEFAULTS = SettingsSchema.parse({});
+
+const useSettingsStore = create<SettingsState>()((set) => {
+  return {
+    ...DEFAULTS,
+
+    setOllamaUrl: (url) => {
+      try {
+        UpdateSettings({ ollamaUrl: url });
+      } catch (e) {
+        console.error("Failed to save setting ollamaUrl:", e);
+      }
+      set({ ollamaUrl: url });
+    },
+
+    syncWithSettings: () => {
+      try {
+        const settings = Settings.getInstance();
+        set(settings.getAll());
+      } catch (e) {
+        console.error("Failed to sync settings:", e);
+      }
+    },
+  } as SettingsState;
+});
+
+export default useSettingsStore;

package/src/theme.ts

@@ -0,0 +1,26 @@
+export const THEME = {
+  primary: "#f5c2e7", // Flamingo - Modern muted pink highlight
+  primaryLight: "#f5e0dc", // Rosewater - Very faint for selections/highlights
+  primaryDark: "#eba0ac", // Maroon - Muted for borders/non-focus
+  primaryDim: "#94e2d5", // Teal - Modern secondary accent
+  success: "#a6e3a1", // Green - Standard terminal success
+  error: "#f38ba8", // Red - Standard terminal error
+  warning: "#f9e2af", // Yellow - Standard terminal warning
+  info: "#89b4fa", // Blue - Standard terminal info
+  text: "#cdd6f4", // Text - Off-white based on modern palettes
+  dim: "#6c7086", // Overlay - Muted grey for metadata
+  border: "#313244", // Surface - Subtle dark border
+  borderFocus: "#f5c2e7", // Match primary for focused state
+  gradient: [
+    { r: 245, g: 194, b: 231 }, // flamingo
+    { r: 203, g: 166, b: 247 }, // mauve
+    { r: 180, g: 190, b: 254 }, // lavender
+    { r: 137, g: 180, b: 250 }, // blue
+    { r: 116, g: 199, b: 236 }, // sapphire
+    { r: 137, g: 220, b: 235 }, // sky
+    { r: 148, g: 226, b: 213 }, // teal
+    { r: 166, g: 227, b: 161 }, // green
+    { r: 249, g: 226, b: 175 }, // yellow
+    { r: 250, g: 179, b: 135 }, // peach
+  ],
+};

package/src/types/Agent.ts

@@ -0,0 +1,147 @@
+import type { z } from "zod";
+import type { ModelMessage, ToolSet, TextStreamPart } from "ai";
+import type { TokenUsage } from "./TokenUsage";
+
+// ============================================================================
+// Agent Configuration Types
+// ============================================================================
+
+/** Reasoning effort levels for reasoning models (e.g., OpenAI o-series, GPT-5) */
+export type ReasoningEffort =
+  | "none"
+  | "minimal"
+  | "low"
+  | "medium"
+  | "high"
+  | "xhigh";
+
+export interface AgentConfig {
+  /** Model identifier (e.g., "llama3.1:latest", "gpt-4", etc.) */
+  model: string;
+
+  /** System prompt that defines agent behavior */
+  systemPrompt?: string;
+
+  /** Temperature for response generation (0.0 - 2.0) */
+  temperature?: number;
+
+  /** Maximum tokens to generate */
+  maxTokens?: number;
+
+  /** Tools available to the agent */
+  tools?: ToolSet;
+
+  /** Maximum number of tool execution steps (default: 5) */
+  maxSteps?: number;
+
+  /** Optional name for the agent instance */
+  name?: string;
+
+  /** Whether to automatically execute tools (default: true) */
+  autoExecuteTools?: boolean;
+
+  /**
+   * Reasoning effort for reasoning models (OpenAI o-series, GPT-5, etc.)
+   * - 'none': No reasoning (only GPT-5.1 models)
+   * - 'minimal': Minimal reasoning
+   * - 'low': Low reasoning effort
+   * - 'medium': Medium reasoning effort (default)
+   * - 'high': High reasoning effort
+   * - 'xhigh': Extra high reasoning (only GPT-5.1-Codex-Max)
+   */
+  reasoningEffort?: ReasoningEffort;
+
+  /** Callback for tool calls */
+  onToolCall?: (toolCall: ToolCallInfo) => void;
+
+  /** Callback for step completion */
+  onStepComplete?: (step: StepInfo) => void;
+
+  /** Callback for each raw stream chunk (for custom handling like usage tracking) */
+  onStreamChunk?: (chunk: TextStreamPart<ToolSet>) => void | Promise<void>;
+
+  /** Abort signal for cancelling the request */
+  abortSignal?: AbortSignal;
+
+  /**
+   * Whether to use an isolated context manager instead of the shared global one.
+   * Set to true for subagents to prevent context contamination with parent agents.
+   * Default: false (uses shared context manager)
+   */
+  useIsolatedContext?: boolean;
+}
+
+// ============================================================================
+// Tool-Related Types
+// ============================================================================
+
+export interface ToolCallInfo {
+  toolCallId?: string;
+  toolName: string;
+  args: unknown;
+  result?: unknown;
+}
+
+export interface StepInfo {
+  stepNumber: number;
+  actions: { role: string; content: string }[];
+  toolCalls: ToolCallInfo[];
+  finishReason: string;
+}
+
+// ============================================================================
+// Agent Response Types
+// ============================================================================
+
+export interface AgentResponse {
+  /** The final text response */
+  text: string;
+
+  /** Token usage statistics */
+  usage: TokenUsage;
+
+  /** Finish reason for the generation */
+  finishReason: string;
+
+  /** All steps taken during generation (for multi-step tool use) */
+  steps: StepInfo[];
+
+  /** All tool calls (and results) made during the conversation */
+  toolCalls: ToolCallInfo[];
+
+  /** Raw response from the provider (for advanced use cases) */
+  raw?: unknown;
+}
+
+export interface StructuredAgentResponse<T> {
+  /** The structured object matching the provided schema */
+  object: T;
+
+  /** Token usage statistics */
+  usage: TokenUsage;
+
+  /** Finish reason for the generation */
+  finishReason: string;
+
+  /** Raw response from the provider */
+  raw?: unknown;
+}
+
+// ============================================================================
+// Message Types (Unified format)
+// ============================================================================
+
+export type AgentMessage = ModelMessage;
+
+export type MessageRole = "system" | "user" | "assistant" | "tool";
+
+export interface SimpleMessage {
+  role: MessageRole;
+  content: string;
+}
+
+// ============================================================================
+// Schema Types for Structured Generation
+// ============================================================================
+
+export type StructuredSchema<T> = z.ZodType<T>;

package/src/types/CommandDefinition.ts

@@ -0,0 +1,8 @@
+export interface Command {
+  name: string;
+  description: string;
+  subcommands?: Command[];
+  action?: (args: string[]) => Promise<void>;
+  usage: string;
+  renderedOptions?: string[];
+}