fraude-code 0.1.0

package/src/agent/index.ts

@@ -0,0 +1,14 @@
+// Agent module exports
+export { default as Agent } from "./agent";
+
+export type {
+  AgentConfig,
+  AgentResponse,
+  StructuredAgentResponse,
+  ToolCallInfo,
+  StepInfo,
+  SimpleMessage,
+  AgentMessage,
+  MessageRole,
+  StructuredSchema,
+} from "@/types/Agent";

package/src/agent/pendingChanges.ts

@@ -0,0 +1,270 @@
+import { structuredPatch } from "diff";
+import { projectPath } from "@/utils";
+import log from "@/utils/logger";
+import { unlink } from "node:fs/promises";
+import AgentCognition from "@/utils/agentCognition";
+
+export interface Hunk {
+  oldStart: number;
+  oldLines: number;
+  newStart: number;
+  newLines: number;
+  lines: string[];
+  linedelimiters?: string[];
+}
+
+export interface DiffPatch {
+  oldFileName?: string;
+  newFileName?: string;
+  oldHeader?: string;
+  newHeader?: string;
+  hunks: Hunk[];
+}
+
+export interface PendingChange {
+  id: string;
+  path: string;
+  type: "edit" | "write";
+  originalContent: string | null;
+  newContent: string;
+  diff: DiffPatch;
+  feedback?: string;
+  hidden?: boolean;
+}
+
+class PendingChangesManager {
+  private changes: Map<string, PendingChange> = new Map();
+
+  public async addChange(
+    path: string,
+    newContent: string,
+    type: "edit" | "write",
+    options?: { hidden?: boolean },
+  ): Promise<PendingChange> {
+    // Normalize to absolute path
+    if (!path.startsWith("/")) {
+      path = `${process.cwd()}/${path}`;
+    }
+
+    // Clean up any double slashes or .
+    // Ideally use path.resolve but simple string concat is often enough or import path module
+    const { resolve } = await import("path");
+    path = resolve(path);
+
+    // Check if there are existing changes for this path
+    const changesList = Array.from(this.changes.values());
+    const latestChange = changesList.reverse().find((c) => c.path === path);
+    // Inherit hidden status if strictly true (was created hidden)
+    // If explicitly provided in options, use that. Otherwise use inherited.
+    const isHidden = options?.hidden ?? latestChange?.hidden;
+
+    const originalContent = latestChange
+      ? latestChange.newContent
+      : (await Bun.file(path).exists())
+        ? await Bun.file(path).text()
+        : "";
+
+    // Create unified diff
+    // For new files, originalContent is empty string.
+    // We use path as both old and new filename for the patch header
+    const diff = structuredPatch(
+      projectPath(path),
+      projectPath(path),
+      originalContent || "",
+      newContent,
+      "",
+      "",
+      { context: 2 },
+    );
+
+    const change: PendingChange = {
+      id: crypto.randomUUID(),
+      path,
+      type,
+      originalContent: type === "edit" ? originalContent : null,
+      newContent,
+      diff,
+      hidden: isHidden,
+    };
+
+    this.changes.set(change.id, change);
+    return change;
+  }
+
+  public getChange(id: string): PendingChange | undefined {
+    return this.changes.get(id);
+  }
+
+  public getChanges(): PendingChange[] {
+    return Array.from(this.changes.values()).filter((c) => !c.hidden);
+  }
+
+  public getAllChangesGrouped(): Record<string, PendingChange[]> {
+    const grouped: Record<string, PendingChange[]> = {};
+    for (const change of this.changes.values()) {
+      if (change.hidden) continue;
+      if (!grouped[change.path]) {
+        grouped[change.path] = [];
+      }
+      grouped[change.path]?.push(change);
+    }
+    return grouped;
+  }
+
+  public hasChanges(): boolean {
+    return Array.from(this.changes.values()).some((c) => !c.hidden);
+  }
+
+  public async applyChange(id: string): Promise<boolean> {
+    const change = this.changes.get(id);
+    if (!change) return false;
+
+    try {
+      await Bun.write(change.path, change.newContent);
+      this.changes.delete(id);
+      log(`Applied change to ${change.path}`);
+
+      // Index the file to update knowledge graph
+      try {
+        const cognition = AgentCognition.getInstance();
+        await cognition.init();
+        // Fire and forget indexing to avoid blocking UI
+        cognition
+          .indexFile(change.path)
+          .catch((e) => log(`Indexing failed for ${change.path}: ${e}`));
+      } catch (e) {
+        log(`Failed to trigger indexing: ${e}`);
+      }
+
+      return true;
+    } catch (error) {
+      if (change) {
+        log(`Failed to apply change to ${change.path}: ${error}`);
+      }
+      return false;
+    }
+  }
+
+  public async applyAll(): Promise<void> {
+    for (const [id, change] of this.changes) {
+      if (change.hidden) continue;
+      await this.applyChange(id);
+    }
+  }
+
+  public async applyChangeTemporary(id: string): Promise<boolean> {
+    const change = this.changes.get(id);
+    if (!change) return false;
+
+    try {
+      await Bun.write(change.path, change.newContent);
+      // Differs from applyChange: DOES NOT DELETE from this.changes
+      log(`Temporarily applied change to ${change.path}`);
+      return true;
+    } catch (error) {
+      if (change) {
+        log(`Failed to apply temporary change to ${change.path}: ${error}`);
+      }
+      return false;
+    }
+  }
+
+  public async applyAllTemporary(): Promise<void> {
+    log(`applyAllTemporary called with ${this.changes.size} changes`);
+    for (const id of this.changes.keys()) {
+      await this.applyChangeTemporary(id);
+    }
+  }
+
+  public async restoreChange(id: string): Promise<boolean> {
+    const change = this.changes.get(id);
+    if (!change) return false;
+
+    try {
+      if (change.originalContent === null) {
+        // It was a new file, so delete it
+        const file = Bun.file(change.path);
+        if (await file.exists()) {
+          await unlink(change.path);
+        }
+      } else {
+        // Restore original content
+        await Bun.write(change.path, change.originalContent);
+      }
+      // Note: We do NOT delete the change from the map, because we are just reverting the disk state
+      // but keeping the "pending change" in memory (e.g. for further editing or final apply).
+      log(`Restored ${change.path}`);
+      return true;
+    } catch (error) {
+      log(`Failed to restore ${change.path}: ${error}`);
+      return false;
+    }
+  }
+
+  public async restoreAll(): Promise<void> {
+    log(`restoreAll called with ${this.changes.size} changes`);
+    // Restore in reverse order to correct handle multiple changes to the same file
+    const ids = Array.from(this.changes.keys()).reverse();
+    for (const id of ids) {
+      await this.restoreChange(id);
+    }
+  }
+
+  public rejectChange(id: string): boolean {
+    return this.changes.delete(id);
+  }
+
+  public rejectAll(): void {
+    this.changes.clear();
+  }
+
+  public addFeedback(id: string, feedback: string): boolean {
+    const change = this.changes.get(id);
+    if (!change) return false;
+
+    change.feedback = feedback;
+    return true;
+  }
+
+  public clear() {
+    this.changes.clear();
+  }
+  /**
+   * Gets the content of a file, accounting for any pending changes.
+   * If there are pending changes, returns the new content of the most recent change.
+   * Otherwise, reads the file from disk.
+   */
+  public async getLatestContent(path: string): Promise<string> {
+    // Check pending changes first (reverse order to find latest)
+    // We include hidden changes here because the agent (e.g., test runner)
+    // needs to see the "current state" including temporary files it just created.
+    const changes = Array.from(this.changes.values()).reverse();
+    const latestChange = changes.find((c) => c.path === path);
+
+    if (latestChange) {
+      return latestChange.newContent;
+    }
+
+    // If no pending changes, read from disk
+    const file = Bun.file(path);
+    if (await file.exists()) {
+      return await file.text();
+    }
+    return "";
+  }
+
+  public getDiffStats(diff: DiffPatch): { added: number; removed: number } {
+    let added = 0;
+    let removed = 0;
+    for (const hunk of diff.hunks) {
+      for (const line of hunk.lines) {
+        if (line.startsWith("+")) added++;
+        if (line.startsWith("-")) removed++;
+      }
+    }
+    return { added, removed };
+  }
+}
+
+const pendingChanges = new PendingChangesManager();
+export default pendingChanges;

package/src/agent/prompts/AskPrompt.txt

@@ -0,0 +1,10 @@
+You are an expert software engineer. Your job is to answer the user's question without making any changes to the codebase.
+
+**WORKFLOW:**
+1. **Analyze** the request. Identify unknowns.
+2. **Research** the unknowns. Use the tools provided to gather information about the codebase.
+ - Use glob tool to find files
+ - Use grep tool to search for specific patterns
+ - Use read tool to read specific files
+ - Use bash tool only to run commands that dont change the codebase like `ls`, `pwd`, `cat`, `echo`, etc. Dont use bash tool unless absolutely necessary.
+3. **Answer** the question.

package/src/agent/prompts/FastPrompt.txt

@@ -0,0 +1,40 @@
+You are an expert software engineer. Your job is to make changes to the codebase based on the user's request.
+
+**WORKFLOW:**
+
+## Phase 1: Research
+1. **Analyze** the request. Identify unknowns.
+2. **Research** any information needed to complete the request using researchSubAgentTool: Which files? How does current implementation work? Dependencies?
+  - CHECK HISTORY: Have you already researched this? If yes, use those facts.
+  - BATCH QUERIES: Ask for all related file context in one go if possible.
+  - DO NOT repeat the same query twice.
+
+## Phase 2: Implementation
+Now that you have all the information you need, you can implement the changes.
+**Complete Request** using the tools provided.
+  - Prioritize using the `editTool` to modify existing files
+  - Use `writeTool` if you need to create a new file
+
+## Phase 3: Testing
+Determine if automated testing is possible:
+
+**IF testable programmatically:**
+1. Use the `testTool` to create a temporary test script (e.g., `temp_test_<task_name>.ts`).
+
+2. Run the test using `testRunnerTool`.
+   - `testRunnerTool` will temporarily apply your pending changes, run the command, and then revert the disk state.
+   - This ensures you are testing the code AS MODIFIED but keeping the environment clean.
+   - **Ensure Correct Imports:** Since tests run in a temporary context or subdirectory, relative imports must be handled carefully.
+     - **Python:** Add the project root to `sys.path` before importing.
+       ```python
+       import sys; import os
+       sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+       ```
+     - **Node/TS:** Use correct relative paths (e.g., `import { foo } from "../src/foo"`) or ensure `tsconfig.json` paths are respected by the runner (e.g., using `bun test`).
+
+3. Capture and analyze output
+4. **Refine Test:** If the test failed due to a syntax error or logic issue IN THE TEST ITSELF (not the code being tested), you can run `testTool` again with the same path to overwrite/fix the test file.
+
+**IF NOT testable programmatically** (UI changes, config changes, env-dependent):
+1. Document what manual verification is needed
+2. Note specific steps the user should take to verify

package/src/agent/prompts/PlannerPrompt.txt

@@ -0,0 +1,51 @@
+You are a Lead Architect creating implementation plans. Analyze → Research → Plan → Create tasks. You do NOT execute code.
+
+**WORKFLOW:**
+1. **Analyze** the request. Identify unknowns.
+2. **Research** using researchSubAgentTool: Which files? How does current implementation work? Dependencies?
+  - CHECK HISTORY: Have you already researched this? If yes, use those facts.
+  - BATCH QUERIES: Ask for all related file context in one go if possible.
+  - DO NOT repeat the same query twice.
+3. **Create plan** using planTool: objective, file paths, approach.
+4. **Create tasks** using todoTool—one atomic task per change.
+5. **FINISH** Once you have created all tasks, STOP.
+
+---
+
+**TASK RULES (VIOLATIONS = WORKER FAILURE)**
+
+Workers execute in **parallel with zero shared context**. No chat history. No research results. No execution order.
+
+**Atomic tasks:**
+- ONE change, ONE file, ONE concern per task
+- "and" in description → split into separate tasks
+
+**Isolation test:** "Can this task succeed if run first, alone?"
+- GOOD: `"Add User type to src/types/User.ts"`
+- BAD: `"Use the User type from Task 1"` (dependency = failure)
+
+**Handling dependencies:**
+- If B needs A's output → merge into one task OR duplicate shared code in each task
+- Never reference other tasks
+
+---
+
+**CONTEXT FIELD (REQUIRED—NO EXCEPTIONS)**
+
+Every task MUST include:
+```
+context: {
+  files: ["path/to/file.ts"],
+  instructions: "Self-contained guidance. What, why, how."
+}
+```
+
+**Rules:**
+- `files[]`: All paths worker needs to read/modify (research first—no guessing)
+- `instructions`: Complete guidance assuming worker knows NOTHING about the request
+
+GOOD: `instructions: "Add zod validation to processInput(). User type in User.ts. Reject empty names, emails without @."`
+
+BAD: `instructions: "Fix the validation issue"` (vague = failure)
+
+---

package/src/agent/prompts/ReviewerPrompt.txt

@@ -0,0 +1,57 @@
+You are an expert code reviewer and tester.
+
+**YOUR ROLE:** Review worker changes → Test → Mark task status.
+
+---
+
+## WORKFLOW
+
+### Phase 1: REVIEW
+
+1. Read the context provided (task description, files, notes)
+2. Use `readTool` to examine the modified files
+3. Run `lspTool` with `analyze` to check for:
+   - Syntax errors
+   - Type errors
+   - Unresolved imports
+4. Manually review for logic errors and edge cases
+
+### Phase 2: TEST
+
+Determine if automated testing is possible:
+
+**IF testable programmatically:**
+1. Use the `testTool` to create a temporary test script (e.g., `temp_test_<task_name>.ts`).
+
+2. Run the test using `testRunnerTool`.
+   - `testRunnerTool` will temporarily apply your pending changes, run the command, and then revert the disk state.
+   - This ensures you are testing the code AS MODIFIED but keeping the environment clean.
+   - **Ensure Correct Imports:** Since tests run in a temporary context or subdirectory, relative imports must be handled carefully.
+     - **Python:** Add the project root to `sys.path` before importing.
+       ```python
+       import sys; import os
+       sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+       ```
+     - **Node/TS:** Use correct relative paths (e.g., `import { foo } from "../src/foo"`) or ensure `tsconfig.json` paths are respected by the runner (e.g., using `bun test`).
+
+3. Capture and analyze output
+4. **Refine Test:** If the test failed due to a syntax error or logic issue IN THE TEST ITSELF (not the code being tested), you can run `testTool` again with the same path to overwrite/fix the test file.
+
+**IF NOT testable programmatically** (UI changes, config changes, env-dependent):
+1. Document what manual verification is needed
+2. Note specific steps the user should take to verify
+
+### Phase 3: CLOSE
+
+**If all checks pass:**
+- Use `todoTool` with `operation: "complete"` and add a summary note
+
+**If issues found:**
+- Use `todoTool` with `operation: "update"`, set `status: "pending"`
+- Add detailed note describing: what failed, expected behavior, suggested fix
+
+---
+
+**CONSTRAINTS:**
+- Always run LSP analysis before marking complete
+- Never mark complete if there are unresolved errors

package/src/agent/prompts/WorkerPrompt.txt

@@ -0,0 +1,33 @@
+You are an expert software engineer executing a specific task.
+
+**YOUR ROLE:** Execute task → Document changes → Hand off for review.
+
+---
+
+## TASK INPUT FORMAT
+
+You will receive structured input:
+- **Task:** What to accomplish
+- **Context:** Files and instructions (JSON with `files[]` and `instructions`)
+- **Notes:** Additional context from planning/prior attempts
+
+## EXECUTION WORKFLOW
+
+1. Parse the task input
+2. Read files listed in Context before modifying
+3. Execute the task using available tools
+4. Mark for review using todoTool and add a note summarizing what you changed
+
+## RULES
+
+- Read files before editing
+- Use Context.files as your starting point
+- Follow Context.instructions precisely
+- If stuck, add a note via the todo tool explaining the blocker
+
+### 1. Mark for Review
+
+Use `todoTool` with `operation: "update"` and set `status: "reviewing"`.
+Add a note summarizing what you changed.
+
+**Do NOT mark as "completed"**—that is the Reviewer's job after testing.

package/src/agent/subagents/askAgent.ts

@@ -0,0 +1,37 @@
+import useSettingsStore from "@/store/useSettingsStore";
+import Agent from "../agent";
+import askPrompt from "../prompts/AskPrompt.txt" with { type: "text" };
+import grepTool from "../tools/grepTool";
+import globTool from "../tools/globTool";
+import readTool from "../tools/readTool";
+import bashTool from "../tools/bashTool";
+let _askAgent: Agent | null = null;
+
+/**
+ * Get the ask agent instance.
+ * Ask Agent is designed to answer questions about the codebase without changing anything
+ */
+export function getAskAgent(): Agent {
+  const currentModel = useSettingsStore.getState().primaryModel;
+
+  if (!_askAgent) {
+    _askAgent = new Agent({
+      model: currentModel,
+      systemPrompt: askPrompt,
+      tools: {
+        grepTool,
+        globTool,
+        readTool,
+        bashTool,
+      },
+      temperature: 0.7,
+      maxSteps: 20,
+      reasoningEffort: "high",
+    });
+  } else if (_askAgent.getModel() !== currentModel) {
+    _askAgent.setModel(currentModel);
+  }
+  return _askAgent;
+}
+
+export default getAskAgent;

package/src/agent/subagents/extractionAgent.ts

@@ -0,0 +1,123 @@
+import useSettingsStore from "@/store/useSettingsStore";
+import Agent from "../agent";
+import type { Fact } from "@/utils/agentCognition";
+import useFraudeStore from "@/store/useFraudeStore";
+import log from "@/utils/logger";
+
+let _extractionAgent: Agent | null = null;
+
+const EXTRACTION_PROMPT = `You are a knowledge extraction agent. Analyze the conversation and extract key learnings about the current state of the codebase AFTER this interaction.
+
+Do not extract facts about your own capabilities or the tools you use.
+
+Output a JSON array of facts with this structure:
+[
+  {
+    "type": "decision" | "fact" | "concept" | "reference",
+    "content": "clear, concise description",
+    "confidence": 0.0-1.0,
+    "file": "optional/path/to/file.ts",
+    "symbol": "optionalFunctionOrClassName"
+  }
+]
+
+Rules:
+- Extract ONLY explicitly stated or clearly implied information about the codebase
+- DO NOT store information about test results from tool calls
+- Do NOT store information about what the user asked for
+- "decision": architectural choices, library selections, design patterns
+- "fact": learned information about the codebase structure
+- "concept": domain knowledge or technical concepts explained
+- "reference": specific file/function relationships mentioned
+- Assign lower confidence (0.5-0.7) to inferred facts
+- Skip trivial or obvious information
+
+**EXTRACT FACTS THAT ARE MEANINGFUL FOR THE CODEBASE AND FOR YOU TO REMEMBER**
+
+Respond with ONLY the JSON array, no other text.`;
+
+/**
+ * Get the extraction agent instance.
+ * Used to extract facts from conversation content using LLM.
+ */
+export function getExtractionAgent(): Agent {
+  const store = useSettingsStore.getState();
+  const currentModel = store.secondaryModel || store.primaryModel;
+
+  if (!_extractionAgent) {
+    _extractionAgent = new Agent({
+      model: currentModel,
+      systemPrompt: EXTRACTION_PROMPT,
+      tools: {},
+      temperature: 0.1,
+      maxSteps: 1,
+      useIsolatedContext: true,
+    });
+  } else if (_extractionAgent.getModel() !== currentModel) {
+    _extractionAgent.setModel(currentModel);
+  }
+  return _extractionAgent;
+}
+
+interface ExtractedFact {
+  type: string;
+  content: string;
+  confidence: number;
+  file?: string;
+  symbol?: string;
+}
+
+/**
+ * Extract facts from conversation content using LLM.
+ * Returns parsed facts ready to be stored in AgentCognition.
+ */
+export async function extractFacts(
+  content: string,
+  sessionId: string,
+): Promise<Omit<Fact, "id" | "timestamp">[]> {
+  const agent = getExtractionAgent();
+  const { updateOutput } = useFraudeStore.getState();
+  log("Extracting facts from conversation:", content);
+  try {
+    const response = await agent.chat(
+      `Extract facts from this conversation:\n\n${content.slice(0, 4000)}`,
+    );
+
+    let jsonStr = response.text;
+    const jsonMatch = response.text.match(/\[[\s\S]*\]/);
+    if (jsonMatch) {
+      jsonStr = jsonMatch[0];
+    }
+
+    let parsed: ExtractedFact[];
+    try {
+      parsed = JSON.parse(jsonStr) as ExtractedFact[];
+    } catch {
+      return [];
+    }
+
+    if (!Array.isArray(parsed)) return [];
+
+    return parsed
+      .filter(
+        (f) =>
+          f.type &&
+          f.content &&
+          f.content.length > 10 &&
+          f.content.length < 300,
+      )
+      .map((f) => ({
+        type: f.type as Fact["type"],
+        content: f.content,
+        data:
+          f.file || f.symbol ? { file: f.file, symbol: f.symbol } : undefined,
+        sessionId,
+        confidence: f.confidence || 0.7,
+      }));
+  } catch (e) {
+    updateOutput("error", "Extraction error: " + e);
+    return [];
+  }
+}
+
+export default getExtractionAgent;

package/src/agent/subagents/fastAgent.ts

@@ -0,0 +1,45 @@
+import useSettingsStore from "@/store/useSettingsStore";
+import Agent from "../agent";
+import researchSubAgentTool from "../subagents/researchSubAgent";
+import fastAgentPrompt from "../prompts/FastPrompt.txt" with { type: "text" };
+import writeTool from "../tools/writeTool";
+import editTool from "../tools/editTool";
+import readTool from "../tools/readTool";
+import bashTool from "../tools/bashTool";
+import grepTool from "../tools/grepTool";
+import testRunnerTool from "../tools/testRunnerTool";
+import testTool from "../tools/testTool";
+let _fastAgent: Agent | null = null;
+
+/**
+ * Get the fast agent instance.
+ * Use to complete a user request without any planning. Use for simple tasks.
+ */
+export function getFastAgent(): Agent {
+  const currentModel = useSettingsStore.getState().primaryModel;
+
+  if (!_fastAgent) {
+    _fastAgent = new Agent({
+      model: currentModel,
+      systemPrompt: fastAgentPrompt,
+      tools: {
+        researchSubAgentTool,
+        readTool,
+        grepTool,
+        writeTool,
+        editTool,
+        bashTool,
+        testTool,
+        testRunnerTool,
+      },
+      temperature: 0.7,
+      maxSteps: 20,
+      reasoningEffort: "high",
+    });
+  } else if (_fastAgent.getModel() !== currentModel) {
+    _fastAgent.setModel(currentModel);
+  }
+  return _fastAgent;
+}
+
+export default getFastAgent;