fraude-code 0.1.0

package/src/agent/subagents/managerAgent.ts

@@ -0,0 +1,36 @@
+import useSettingsStore from "@/store/useSettingsStore";
+import Agent from "../agent";
+import planTool from "../tools/planTool";
+import todoTool from "../tools/todoTool";
+import researchSubAgentTool from "../subagents/researchSubAgent";
+import managerPrompt from "../prompts/PlannerPrompt.txt" with { type: "text" };
+
+let _managerAgent: Agent | null = null;
+
+/**
+ * Get the manager agent instance.
+ * Uses lazy initialization to ensure settings are loaded before reading primaryModel.
+ */
+export function getManagerAgent(): Agent {
+  const currentModel = useSettingsStore.getState().primaryModel;
+
+  if (!_managerAgent) {
+    _managerAgent = new Agent({
+      model: currentModel,
+      systemPrompt: managerPrompt,
+      tools: {
+        planTool,
+        todoTool,
+        researchSubAgentTool,
+      },
+      temperature: 0.7,
+      maxSteps: 20,
+      reasoningEffort: "high",
+    });
+  } else if (_managerAgent.getModel() !== currentModel) {
+    _managerAgent.setModel(currentModel);
+  }
+  return _managerAgent;
+}
+
+export default getManagerAgent;

package/src/agent/subagents/relationAgent.ts

@@ -0,0 +1,76 @@
+import useSettingsStore from "@/store/useSettingsStore";
+import Agent from "../agent";
+import log from "@/utils/logger";
+
+let _relationAgent: Agent | null = null;
+
+const RELATION_PROMPT = `You classify relationships between knowledge facts.
+
+Given two facts, determine their relationship type. Output ONLY one of:
+- DEPENDS_ON: First fact relies on or requires the second
+- IMPLEMENTS: First fact is a concrete implementation of the second
+- MODIFIES: First fact changes or affects the second
+- USES: First fact utilizes or references the second
+- RELATED_TO: General semantic relationship (default if unsure)
+
+Output format: Just the relationship type, nothing else.`;
+
+/**
+ * Get the relation classification agent instance.
+ */
+export function getRelationAgent(): Agent {
+  const store = useSettingsStore.getState();
+  const currentModel = store.secondaryModel || store.primaryModel;
+
+  if (!_relationAgent) {
+    _relationAgent = new Agent({
+      model: currentModel,
+      systemPrompt: RELATION_PROMPT,
+      tools: {},
+      temperature: 0.1,
+      maxSteps: 1,
+      useIsolatedContext: true,
+    });
+  } else if (_relationAgent.getModel() !== currentModel) {
+    _relationAgent.setModel(currentModel);
+  }
+  return _relationAgent;
+}
+
+export type RelationType =
+  | "DEPENDS_ON"
+  | "IMPLEMENTS"
+  | "MODIFIES"
+  | "USES"
+  | "RELATED_TO";
+
+/**
+ * Classify the relationship between two facts using LLM.
+ */
+export async function classifyRelation(
+  factA: string,
+  factB: string,
+): Promise<RelationType> {
+  const agent = getRelationAgent();
+
+  try {
+    const response = await agent.chat(
+      `Fact A: "${factA}"\nFact B: "${factB}"\n\nRelationship type:`,
+    );
+
+    const text = response.text.trim().toUpperCase();
+
+    // Parse response to valid relation type
+    if (text.includes("DEPENDS_ON")) return "DEPENDS_ON";
+    if (text.includes("IMPLEMENTS")) return "IMPLEMENTS";
+    if (text.includes("MODIFIES")) return "MODIFIES";
+    if (text.includes("USES")) return "USES";
+
+    return "RELATED_TO";
+  } catch (e) {
+    log("Relation classification failed: " + e);
+    return "RELATED_TO";
+  }
+}
+
+export default getRelationAgent;

package/src/agent/subagents/researchSubAgent.ts

@@ -0,0 +1,79 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { Agent } from "@/agent";
+import readTool from "../tools/readTool";
+import bashTool from "../tools/bashTool";
+import grepTool from "../tools/grepTool";
+import globTool from "../tools/globTool";
+import useFraudeStore from "@/store/useFraudeStore";
+import useSettingsStore from "@/store/useSettingsStore";
+import lspTool from "../tools/lspTool";
+
+const researchSubAgentTool = tool({
+  description: `Ask a specialized researcher to find information in the codebase.
+    Use this BEFORE making edits to ensure you know the file structure and logic.`,
+  strict: true,
+  inputSchema: z.object({
+    question: z
+      .string()
+      .describe("The specific question about the code to answer."),
+  }),
+  execute: async ({ question }) => {
+    const { updateOutput, researchCache } = useFraudeStore.getState();
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Searching for context",
+        details: question,
+        result: "",
+      }),
+      { dontOverride: true },
+    );
+    if (researchCache?.[question]) {
+      updateOutput(
+        "toolCall",
+        JSON.stringify({
+          action: "Explored context",
+          details: question,
+          result: researchCache[question],
+        }),
+      );
+      return researchCache[question];
+    }
+    const subagent = new Agent({
+      model: useSettingsStore.getState().secondaryModel,
+      systemPrompt: prompt,
+      tools: { readTool, bashTool, grepTool, globTool, lspTool },
+      temperature: 0.7,
+      maxSteps: 10,
+      useIsolatedContext: true,
+    });
+    const result = await subagent.chat(question);
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Explored context",
+        details: question,
+        result: result.text,
+      }),
+    );
+    useFraudeStore.setState({
+      researchCache: {
+        ...researchCache,
+        [question]: result.text,
+      },
+    });
+    return result.text;
+  },
+});
+
+export default researchSubAgentTool;
+
+const prompt = `
+You are a read-only research assistant.
+Your goal is to answer the user's question by exploring the file system.
+- You cannot edit files.
+- Be aggressive with your tools to find answers.
+- When finding code relevant to the question, extract the *signature* (function names, params, types) and *critical logic*.
+- Do not dump entire files, but provide enough technical detail that a developer could call this function without seeing the code.
+`;

package/src/agent/subagents/reviewerSubAgent.ts

@@ -0,0 +1,42 @@
+import { Agent } from "@/agent";
+import readTool from "../tools/readTool";
+import grepTool from "../tools/grepTool";
+import lspTool from "../tools/lspTool";
+import useSettingsStore from "@/store/useSettingsStore";
+import todoTool from "../tools/todoTool";
+import testRunnerTool from "../tools/testRunnerTool";
+import testTool from "../tools/testTool";
+import ReviewerPrompt from "../prompts/ReviewerPrompt.txt" with { type: "text" };
+
+let _reviewerSubAgent: Agent | null = null;
+
+/**
+ * Get the reviewer subagent instance.
+ * Uses lazy initialization to ensure settings are loaded before reading secondaryModel.
+ */
+export function getReviewerSubAgent(): Agent {
+  const currentModel = useSettingsStore.getState().secondaryModel;
+
+  if (!_reviewerSubAgent) {
+    _reviewerSubAgent = new Agent({
+      model: currentModel,
+      systemPrompt: ReviewerPrompt,
+      tools: {
+        readTool,
+        grepTool,
+        lspTool,
+        testTool,
+        todoTool,
+        testRunnerTool,
+      },
+      temperature: 0.7,
+      maxSteps: 10,
+      useIsolatedContext: true,
+    });
+  } else if (_reviewerSubAgent.getModel() !== currentModel) {
+    _reviewerSubAgent.setModel(currentModel);
+  }
+  return _reviewerSubAgent;
+}
+
+export default getReviewerSubAgent;

package/src/agent/subagents/workerSubAgent.ts

@@ -0,0 +1,42 @@
+import { Agent } from "@/agent";
+import readTool from "../tools/readTool";
+import grepTool from "../tools/grepTool";
+import writeTool from "../tools/writeTool";
+import editTool from "../tools/editTool";
+import bashTool from "../tools/bashTool";
+import todoTool from "../tools/todoTool";
+import useSettingsStore from "@/store/useSettingsStore";
+import WorkerPrompt from "../prompts/WorkerPrompt.txt" with { type: "text" };
+
+let _workerSubAgent: Agent | null = null;
+
+/**
+ * Get the worker subagent instance.
+ * Uses lazy initialization to ensure settings are loaded before reading primaryModel.
+ */
+export function getWorkerSubAgent(): Agent {
+  const currentModel = useSettingsStore.getState().primaryModel;
+
+  if (!_workerSubAgent) {
+    _workerSubAgent = new Agent({
+      model: currentModel,
+      systemPrompt: WorkerPrompt,
+      tools: {
+        readTool,
+        grepTool,
+        writeTool,
+        editTool,
+        bashTool,
+        todoTool,
+      },
+      temperature: 0.7,
+      maxSteps: 10,
+      useIsolatedContext: true,
+    });
+  } else if (_workerSubAgent.getModel() !== currentModel) {
+    _workerSubAgent.setModel(currentModel);
+  }
+  return _workerSubAgent;
+}
+
+export default getWorkerSubAgent;

package/src/agent/tools/bashTool.ts

@@ -0,0 +1,94 @@
+import { tool } from "ai";
+import { z } from "zod";
+import useFraudeStore from "@/store/useFraudeStore";
+import DESCRIPTION from "./descriptions/bash.txt" with { type: "text" };
+
+const { updateOutput } = useFraudeStore.getState();
+
+const bashTool = tool({
+  description: DESCRIPTION,
+  strict: true,
+  inputSchema: z.object({
+    command: z.string().describe("The command to execute"),
+    timeout: z
+      .number()
+      .describe("Optional timeout in milliseconds")
+      .default(120000),
+    workdir: z
+      .string()
+      .describe(
+        `The working directory to run the command in. Defaults to project root ${process.cwd()}. Use this instead of 'cd' commands.`,
+      )
+      .optional(),
+    description: z
+      .string()
+      .describe(
+        "Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'",
+      ),
+  }),
+  execute: async ({
+    command,
+    timeout,
+    workdir,
+    description,
+  }: {
+    command: string;
+    timeout: number;
+    workdir?: string;
+    description: string;
+  }) => {
+    const forbidden = ["rm -rf /", ":(){:|:&};:"];
+    if (forbidden.some((bad) => command.includes(bad))) {
+      throw new Error("Command blocked by safety policy");
+    }
+
+    try {
+      updateOutput(
+        "toolCall",
+        JSON.stringify({
+          action: "Executing Bash",
+          details: command,
+          result: "",
+        }),
+        { dontOverride: true },
+      );
+
+      const proc = Bun.spawn(["sh", "-c", command], {
+        cwd: workdir || process.cwd(),
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const timeoutSignal = AbortSignal.timeout(timeout);
+
+      const outputPromise = new Response(proc.stdout).text();
+      const errorPromise = new Response(proc.stderr).text();
+      if (timeoutSignal.aborted) {
+        proc.kill();
+        throw new Error("Command timed out");
+      }
+
+      const [stdout, stderr] = await Promise.all([outputPromise, errorPromise]);
+      const exitCode = await proc.exited;
+
+      updateOutput(
+        "toolCall",
+        JSON.stringify({
+          action: "Bash",
+          details: command,
+          result: stdout.trim(),
+        }),
+      );
+      return {
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        code: exitCode,
+        cwd: workdir || process.cwd(),
+      };
+    } catch (err: any) {
+      throw new Error(`Execution failed: ${err.message}`);
+    }
+  },
+});
+
+export default bashTool;

package/src/agent/tools/descriptions/bash.txt

@@ -0,0 +1,47 @@
+Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.
+
+All commands run in ${directory} by default. Use the `workdir` parameter if you need to run a command in a different directory. AVOID using `cd <directory> && <command>` patterns - use `workdir` instead.
+
+IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file operations (reading, writing, editing, searching, finding files) - use the specialized tools for this instead.
+
+Before executing the command, please follow these steps:
+
+1. Directory Verification:
+   - If the command will create new directories or files, first use `ls` to verify the parent directory exists and is the correct location
+   - For example, before running "mkdir foo/bar", first use `ls foo` to check that "foo" exists and is the intended parent directory
+
+2. Command Execution:
+   - Always quote file paths that contain spaces with double quotes (e.g., rm "path with spaces/file.txt")
+   - Examples of proper quoting:
+     - mkdir "/Users/name/My Documents" (correct)
+     - mkdir /Users/name/My Documents (incorrect - will fail)
+     - python "/path/with spaces/script.py" (correct)
+     - python /path/with spaces/script.py (incorrect - will fail)
+   - After ensuring proper quoting, execute the command.
+   - Capture the output of the command.
+
+Usage notes:
+  - The command argument is required.
+  - You can specify an optional timeout in milliseconds. If not specified, commands will time out after 120000ms (2 minutes).
+  - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
+  - If the output exceeds ${maxLines} lines or ${maxBytes} bytes, it will be truncated and the full output will be written to a file. You can use Read with offset/limit to read specific sections or Grep to search the full content. Because of this, you do NOT need to use `head`, `tail`, or other truncation commands to limit output - just run the command directly.
+
+  - Avoid using Bash with the `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:
+    - File search: Use Glob tool (NOT find or ls)
+    - Content search: Use Grep tool (NOT grep or rg)
+    - Read files: Use Read tool (NOT cat/head/tail)
+    - Edit files: Use Edit tool (NOT sed/awk)
+    - Write files: Use Write tool (NOT echo >/cat <<EOF)
+    - Communication: Output text directly (NOT echo/printf)
+  - When issuing multiple commands:
+    - If the commands are independent and can run in parallel, make multiple Bash tool calls in a single message. For example, if you need to run "git status" and "git diff", send a single message with two Bash tool calls in parallel.
+    - If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them together (e.g., `git add . && git commit -m "message" && git push`). For instance, if one operation must complete before another starts (like mkdir before cp, Write before Bash for git operations, or git add before git commit), run these operations sequentially instead.
+    - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
+    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)
+  - AVOID using `cd <directory> && <command>`. Use the `workdir` parameter to change directories instead.
+    <good-example>
+    Use workdir="/foo/bar" with command: pytest tests
+    </good-example>
+    <bad-example>
+    cd /foo/bar && pytest tests
+    </bad-example>

package/src/agent/tools/descriptions/edit.txt

@@ -0,0 +1,7 @@
+Edit an existing file by replacing a specific block of text with new content. Use the read tool first to understand the current content of the file.
+
+Usage:
+- Make sure the old_content is a unique block of text within the file.
+- Include enough context in the old_content to ensure uniqueness.
+- If adding new content, include context around the new content to ensure uniqueness and to specify the location of the new content in the file.
+- If removing, new content should be empty.

package/src/agent/tools/descriptions/glob.txt

@@ -0,0 +1,4 @@
+- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns files sorted by last modified date
+- Use this tool when you need to find files by name patterns

package/src/agent/tools/descriptions/grep.txt

@@ -0,0 +1,8 @@
+Search for a chunk of text in the codebase using grep. Use this tool when looking for a specific pattern in the codebase.
+
+- Fast content search tool that works with any codebase size
+- Searches file contents using regular expressions
+- Supports full regex syntax (eg. "log.*Error", "function\s+\w+", etc.)
+- Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}")
+- Returns file paths and line numbers with at least one match sorted by modification time
+- Use this tool when you need to find files containing specific patterns

package/src/agent/tools/descriptions/lsp.txt

@@ -0,0 +1,20 @@
+Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+
+Supported operations:
+- goToDefinition: Find where a symbol is defined
+- findReferences: Find all references to a symbol
+- hover: Get hover information (documentation, type info) for a symbol
+- documentSymbol: Get all symbols (functions, classes, variables) in a document
+- workspaceSymbol: Search for symbols across the entire workspace
+- goToImplementation: Find implementations of an interface or abstract method
+- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
+- incomingCalls: Find all functions/methods that call the function at a position
+- outgoingCalls: Find all functions/methods called by the function at a position
+
+## Parameters:
+- **filePath**: Path to the file containing the symbol
+- **symbol**: The exact name of the function, class, variable, or import to look up
+- **occurrence**: If symbol appears multiple times, which one to use (default: 1 = first)
+
+## Supported Languages:
+TypeScript, JavaScript, Python, Rust, Go, C/C++, JSON, CSS, HTML

package/src/agent/tools/descriptions/plan.txt

@@ -0,0 +1,3 @@
+Manage the project plan. 
+ALWAYS read this at the start of a turn to see what is left to do.
+Update this when a sub-agent completes a task.

package/src/agent/tools/descriptions/read.txt

@@ -0,0 +1,9 @@
+Read a file from the local file system.
+If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The filePath parameter must be an absolute path, not a relative path
+- By default, this tool will read up to 500 lines of the file.
+- You can optionally specify the offset and limit parameters to read a specific range of lines.
+- The offset parameter is the line number to start reading from (inclusive). Line 0 is the first line.
+- The limit parameter is the number of lines to read (inclusive).

package/src/agent/tools/descriptions/todo.txt

@@ -0,0 +1,12 @@
+Manage tasks for worker agents.
+
+Operations:
+- "add": Create task with description and context (files + instructions)
+- "update": Update task status or add notes
+- "complete": Mark task done with optional completion note
+- "list": Get all tasks with summary
+- "clear": Remove completed tasks
+
+Task context includes:
+- files: Array of file paths relevant to the task
+- instructions: Specific instructions for the worker agent

package/src/agent/tools/descriptions/write.txt

@@ -0,0 +1,8 @@
+Writes a file to the local filesystem. Use to create new files or overwrite entire files.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.

package/src/agent/tools/editTool.ts

@@ -0,0 +1,44 @@
+import { tool } from "ai";
+import { z } from "zod";
+import useFraudeStore from "@/store/useFraudeStore";
+import { projectPath } from "@/utils";
+import pendingChanges from "@/agent/pendingChanges";
+
+import DESCRIPTION from "./descriptions/edit.txt" with { type: "text" };
+const { updateOutput } = useFraudeStore.getState();
+
+const editTool = tool({
+  description: DESCRIPTION,
+  strict: true,
+  inputSchema: z.object({
+    path: z.string().describe("The path to the file to edit"),
+    old_content: z
+      .string()
+      .describe(
+        "Must be unique and match the file exactly (whitespace matters)",
+      ),
+    new_content: z.string().describe("The new content of the file"),
+  }),
+  execute: async ({ path, old_content, new_content }) => {
+    const fileContent = await pendingChanges.getLatestContent(path);
+    if (!fileContent.includes(old_content)) {
+      throw new Error("Old content does not match file");
+    }
+    const newFileContent = fileContent.replace(old_content, new_content);
+
+    const change = await pendingChanges.addChange(path, newFileContent, "edit");
+    const stats = pendingChanges.getDiffStats(change.diff);
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Edited File",
+        details: path,
+        result: `(+${stats.added} / -${stats.removed})`,
+      }),
+      { dontOverride: true },
+    );
+    return { success: true };
+  },
+});
+
+export default editTool;

package/src/agent/tools/globTool.ts

@@ -0,0 +1,59 @@
+import { tool } from "ai";
+import { z } from "zod";
+import useFraudeStore from "@/store/useFraudeStore";
+import DESCRIPTION from "./descriptions/glob.txt" with { type: "text" };
+import { Glob } from "bun";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const globTool = tool({
+  description: DESCRIPTION,
+  strict: true,
+  inputSchema: z.object({
+    pattern: z.string().describe("The glob pattern to match files with"),
+    path: z
+      .string()
+      .optional()
+      .describe(
+        `The directory to search in. If not specified, the current directory will be searched. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.`,
+      ),
+  }),
+  execute: async ({ pattern, path }: { pattern: string; path?: string }) => {
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Searching Files in " + path,
+        details: pattern,
+      }),
+      { dontOverride: true },
+    );
+    const searchPath = path || process.cwd();
+    const glob = new Glob(pattern);
+    const files: { file: string; modifiedAt: number }[] = [];
+    const MAX_FILES = 100;
+    for await (const file of glob.scan({ cwd: searchPath, absolute: false })) {
+      if (file.includes("node_modules") || file.includes(".git")) continue;
+      const f = Bun.file(file);
+      const stats = await f.stat().catch(() => null);
+      const modifiedAt = stats?.mtime.getTime() || 0;
+      files.push({ file, modifiedAt });
+      if (files.length >= MAX_FILES) {
+        break;
+      }
+    }
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Found " + files.length + " Files",
+        details: pattern,
+      }),
+    );
+    if (files.length === 0) return "No files found matching that pattern.";
+    return files
+      .sort((a, b) => b.modifiedAt - a.modifiedAt)
+      .map((f) => f.file)
+      .join("\n");
+  },
+});
+
+export default globTool;