fraude-code 0.1.0

package/src/agent/tools/rememberTool.ts

@@ -0,0 +1,91 @@
+import { tool } from "ai";
+import { z } from "zod";
+import useFraudeStore from "@/store/useFraudeStore";
+import AgentCognition from "@/utils/agentCognition";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const DESCRIPTION = `Store important information for future sessions.
+
+Use this tool to remember key facts, decisions, concepts, or file references that should persist across agent sessions. The agent will automatically validate and retrieve relevant knowledge in future sessions.
+
+Types:
+- fact: Learned information about the codebase (e.g., "API uses REST with JWT auth")
+- decision: Architectural or implementation choices (e.g., "Using Zustand over Redux")
+- concept: Domain knowledge (e.g., "User sessions expire after 24h")
+- reference: File or function relationships (e.g., "auth.ts handles all authentication")
+
+For references, include file paths to enable validation.`;
+
+const rememberTool = tool({
+  description: DESCRIPTION,
+  strict: true,
+  inputSchema: z.object({
+    fact: z.string().describe("The information to remember"),
+    type: z
+      .enum(["fact", "decision", "concept", "reference"])
+      .describe("Type of knowledge being stored"),
+    file: z
+      .string()
+      .optional()
+      .describe("Optional file path this knowledge relates to"),
+    symbol: z
+      .string()
+      .optional()
+      .describe("Optional function/class name this knowledge relates to"),
+    confidence: z
+      .number()
+      .min(0)
+      .max(1)
+      .default(0.9)
+      .describe(
+        "Confidence level (0-1). Default 0.9 for explicit user requests",
+      ),
+  }),
+  execute: async ({
+    fact,
+    type,
+    file,
+    symbol,
+    confidence,
+  }: {
+    fact: string;
+    type: "fact" | "decision" | "concept" | "reference";
+    file?: string;
+    symbol?: string;
+    confidence: number;
+  }) => {
+    const cognition = AgentCognition.getInstance();
+    await cognition.init();
+
+    // Build data object
+    const data: Record<string, string> = {};
+    if (file) data.file = file;
+    if (symbol) data.symbol = symbol;
+
+    const id = await cognition.addFact({
+      type,
+      content: fact,
+      data: Object.keys(data).length > 0 ? data : undefined,
+      confidence,
+    });
+
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Remember",
+        details: fact,
+        result: `Stored as ${type}`,
+      }),
+      { dontOverride: true },
+    );
+
+    return {
+      success: true,
+      id,
+      message: `Remembered: "${fact}" as ${type}`,
+    };
+  },
+});
+
+export default rememberTool;

package/src/agent/tools/testRunnerTool.ts

@@ -0,0 +1,77 @@
+import { tool } from "ai";
+import { z } from "zod";
+import pendingChanges from "@/agent/pendingChanges";
+import useFraudeStore from "@/store/useFraudeStore";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+const { updateOutput } = useFraudeStore.getState();
+
+const testRunnerTool = tool({
+  description: `Run a shell command to verify the codebase state, INCLUDING pending changes.
+  Crucial for testing changes before they are permanently applied.
+  
+  HOW IT WORKS:
+  1. Temporarily applies ALL pending changes to disk.
+  2. Runs your command (e.g., 'bun test').
+  3. IMMEDIATELY restores the file system to its previous state.
+  
+  Use this to verify your changes actually work.`,
+  strict: true,
+  inputSchema: z.object({
+    command: z
+      .string()
+      .describe(
+        "The shell command to run (e.g., 'bun test tests/my.test.ts', 'python3 tests/test_app.py')",
+      ),
+  }),
+  execute: async ({ command }) => {
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Running Test on Pending State",
+        details: command,
+        result: "...",
+      }),
+      { dontOverride: true },
+    );
+
+    try {
+      // 1. Apply Changes
+      await pendingChanges.applyAllTemporary();
+
+      // 2. Run Command
+      try {
+        const { stdout, stderr } = await execAsync(command);
+        const result = `STDOUT:\n${stdout}\n\nSTDERR:\n${stderr}`;
+
+        updateOutput(
+          "toolCall",
+          JSON.stringify({
+            action: "Test Result",
+            details: command,
+            result: stdout.slice(0, 100) + (stdout.length > 100 ? "..." : ""),
+          }),
+        );
+        return result;
+      } catch (error: any) {
+        const result = `Command Failed:\n${error.message}\n\nSTDOUT:\n${error.stdout}\n\nSTDERR:\n${error.stderr}`;
+        updateOutput(
+          "toolCall",
+          JSON.stringify({
+            action: "Test Failed",
+            details: command,
+            result: "Exit Code: " + error.code,
+          }),
+        );
+        return result;
+      }
+    } finally {
+      // 3. Restore State
+      await pendingChanges.restoreAll();
+    }
+  },
+});
+
+export default testRunnerTool;

package/src/agent/tools/testTool.ts

@@ -0,0 +1,44 @@
+import { tool } from "ai";
+import { z } from "zod";
+import useFraudeStore from "@/store/useFraudeStore";
+import pendingChanges from "@/agent/pendingChanges";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const testTool = tool({
+  description: `Create OR UPDATE a TEMPORARY test file to verify changes. 
+  This file will NOT be saved to the project permanently and will NOT appear in the user's pending changes list.
+  Use this tool specifically when you want to create a reproduction script or a new test case to verify your changes without cluttering the project.
+  If you need to fix a mistake in the test file, simply call this tool again with the same path and the corrected content.`,
+  strict: true,
+  inputSchema: z.object({
+    path: z
+      .string()
+      .describe(
+        "The path to the temporary test file (e.g., 'tests/temp_repro.test.ts')",
+      ),
+    content: z.string().describe("The content of the test file"),
+  }),
+  execute: async ({ path, content }) => {
+    // Add change with hidden: true
+    const change = await pendingChanges.addChange(path, content, "write", {
+      hidden: true,
+    });
+
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Created Temporary Test",
+        details: path,
+        result: "(Hidden from pending changes)",
+      }),
+      { dontOverride: true },
+    );
+    return {
+      success: true,
+      message: `Created temporary test at ${path}. You can now run it using testRunnerTool.`,
+    };
+  },
+});
+
+export default testTool;

package/src/agent/tools/todoTool.ts

@@ -0,0 +1,224 @@
+import { tool } from "ai";
+import { z } from "zod";
+import path from "path";
+import useFraudeStore from "@/store/useFraudeStore";
+import DESCRIPTION from "./descriptions/todo.txt" with { type: "text" };
+
+const { updateOutput } = useFraudeStore.getState();
+
+// Path configuration
+const FRAUDE_DIR = path.join(process.cwd(), ".fraude");
+const TODOS_FILE = path.join(FRAUDE_DIR, "todos.json");
+
+// Context for worker agents
+interface TaskContext {
+  files: string[];
+  instructions: string;
+}
+
+// Todo item schema
+export interface TodoItem {
+  id: string;
+  description: string;
+  status: "pending" | "in-progress" | "reviewing" | "completed";
+  context?: TaskContext;
+  notes: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface TodoState {
+  todos: TodoItem[];
+}
+
+// Helper to read current todos
+async function readTodos(): Promise<TodoState> {
+  const file = Bun.file(TODOS_FILE);
+  if (await file.exists()) {
+    const text = await file.text();
+    return JSON.parse(text);
+  }
+  return { todos: [] };
+}
+
+// Helper to write todos
+async function writeTodos(state: TodoState): Promise<void> {
+  await Bun.write(TODOS_FILE, JSON.stringify(state, null, 2));
+}
+
+// Generate unique ID
+function generateId(): string {
+  return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
+}
+
+const todoTool = tool({
+  description: DESCRIPTION,
+  strict: true,
+  inputSchema: z.object({
+    operation: z
+      .enum(["add", "update", "complete", "list", "clear"])
+      .describe("The operation to perform"),
+    id: z
+      .string()
+      .optional()
+      .describe("Task ID (required for update/complete)"),
+    description: z
+      .string()
+      .optional()
+      .describe("Task description (required for add)"),
+    context: z
+      .object({
+        files: z.array(z.string()).describe("Relevant file paths"),
+        instructions: z
+          .string()
+          .describe("Specific instructions for the worker"),
+      })
+      .optional()
+      .describe("Pre-researched context for the worker (for add)"),
+    status: z
+      .enum(["pending", "in-progress", "reviewing", "completed"])
+      .optional()
+      .describe("New status (for update)"),
+    note: z.string().optional().describe("Note to append"),
+  }),
+
+  execute: async ({ operation, id, description, context, status, note }) => {
+    const state = await readTodos();
+    const now = new Date().toISOString();
+
+    switch (operation) {
+      case "add": {
+        if (!description) throw new Error("Description required");
+        const newTodo: TodoItem = {
+          id: generateId(),
+          description,
+          status: "pending",
+          context,
+          notes: note ? [note] : [],
+          createdAt: now,
+          updatedAt: now,
+        };
+        state.todos.push(newTodo);
+        await writeTodos(state);
+        updateOutput(
+          "toolCall",
+          JSON.stringify({
+            action: "Added Task",
+            details: description,
+            result: newTodo.id,
+          }),
+          { dontOverride: true },
+        );
+        return { success: true, id: newTodo.id };
+      }
+
+      case "update": {
+        if (!id) throw new Error("ID required");
+        const todo = state.todos.find((t) => t.id === id);
+        if (!todo) throw new Error(`Task not found: ${id}`);
+        if (status) todo.status = status;
+        if (note) todo.notes.push(note);
+        todo.updatedAt = now;
+        await writeTodos(state);
+        updateOutput(
+          "toolCall",
+          JSON.stringify({
+            action: "Updated Task",
+            details: todo.description,
+            result: status || "note added",
+          }),
+          { dontOverride: true },
+        );
+        return { success: true };
+      }
+
+      case "complete": {
+        if (!id) throw new Error("ID required");
+        const todo = state.todos.find((t) => t.id === id);
+        if (!todo) throw new Error(`Task not found: ${id}`);
+        todo.status = "completed";
+        if (note) todo.notes.push(`[Done] ${note}`);
+        todo.updatedAt = now;
+        await writeTodos(state);
+        updateOutput(
+          "toolCall",
+          JSON.stringify({
+            action: "Completed Task",
+            details: todo.description,
+            result: "✓",
+          }),
+          { dontOverride: true },
+        );
+        return { success: true };
+      }
+
+      case "list": {
+        const summary = {
+          total: state.todos.length,
+          pending: state.todos.filter((t) => t.status === "pending").length,
+          inProgress: state.todos.filter((t) => t.status === "in-progress")
+            .length,
+          completed: state.todos.filter((t) => t.status === "completed").length,
+        };
+        updateOutput(
+          "toolCall",
+          JSON.stringify({
+            action: "Listed Tasks",
+            details: `${summary.pending} pending, ${summary.inProgress} in-progress`,
+            result: `${summary.total} total`,
+          }),
+          { dontOverride: true },
+        );
+        return { todos: state.todos, summary };
+      }
+
+      case "clear": {
+        const before = state.todos.length;
+        state.todos = state.todos.filter((t) => t.status !== "completed");
+        await writeTodos(state);
+        updateOutput(
+          "toolCall",
+          JSON.stringify({
+            action: "Cleared Completed",
+            details: `Removed ${before - state.todos.length} tasks`,
+            result: "✓",
+          }),
+          { dontOverride: true },
+        );
+        return { success: true, remaining: state.todos.length };
+      }
+    }
+  },
+});
+
+export const getNextTodo = async () => {
+  const state = await readTodos();
+  const nextTodo = state.todos.find((t) => t.status === "pending");
+  if (!nextTodo) {
+    return { done: true, task: null };
+  }
+  // Mark as in-progress
+  nextTodo.status = "in-progress";
+  nextTodo.updatedAt = new Date().toISOString();
+  await writeTodos(state);
+  return {
+    done: false,
+    task: nextTodo,
+  };
+};
+
+export const getTodoById = async (id: string) => {
+  const state = await readTodos();
+  return state.todos.find((t) => t.id === id);
+};
+
+/**
+ * Check if there are any pending todos without modifying state.
+ * Used to validate that the manager agent created tasks.
+ */
+export const hasPendingTodos = async (): Promise<boolean> => {
+  const state = await readTodos();
+  return state.todos.some((t) => t.status === "pending");
+};
+
+export default todoTool;

package/src/agent/tools/writeTool.ts

@@ -0,0 +1,33 @@
+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/write.txt" with { type: "text" };
+const { updateOutput } = useFraudeStore.getState();
+
+const writeTool = tool({
+  description: DESCRIPTION,
+  strict: true,
+  inputSchema: z.object({
+    path: z.string().describe("The path to the file to write"),
+    content: z.string().describe("The content to write to the file"),
+  }),
+  execute: async ({ path, content }) => {
+    const change = await pendingChanges.addChange(path, content, "write");
+    const stats = pendingChanges.getDiffStats(change.diff);
+    updateOutput(
+      "toolCall",
+      JSON.stringify({
+        action: "Created File",
+        details: path,
+        result: `(+${stats.added} / -${stats.removed})`,
+      }),
+      { dontOverride: true },
+    );
+    return { success: true };
+  },
+});
+
+export default writeTool;

package/src/commands/COMMANDS.ts

@@ -0,0 +1,38 @@
+import type { Command } from "../types/CommandDefinition";
+import modelCommands from "./model";
+import openRouterCommands from "./openrouter";
+import cerebrasCommands from "./cerebras";
+import groqCommands from "./groq";
+import googleCommands from "./google";
+import mistralCommands from "./mistral";
+import modelsCommands from "./models";
+import ollamaCommand from "./ollama";
+import sessionCommands from "./session";
+import usageCommand from "./usage";
+import serveCommand from "./serve";
+import logCommand from "./log";
+import rememberCommand from "./remember";
+import knowledgeCommand from "./knowledge";
+import forgetCommand from "./forget";
+import visualizeCommand from "./visualize";
+
+const COMMANDS: Command[] = [
+  usageCommand,
+  logCommand,
+  serveCommand,
+  sessionCommands,
+  rememberCommand,
+  knowledgeCommand,
+  forgetCommand,
+  visualizeCommand,
+  modelCommands, //starts with model
+  modelsCommands, //starts with models
+  ollamaCommand,
+  openRouterCommands,
+  cerebrasCommands,
+  groqCommands,
+  googleCommands,
+  mistralCommands,
+];
+
+export default COMMANDS;

package/src/commands/cerebras/auth.ts

@@ -0,0 +1,27 @@
+import { UpdateSettings } from "src/config/settings";
+import useFraudeStore from "src/store/useFraudeStore";
+import CerebrasClient from "@/services/cerebras";
+import type { Command } from "@/types/CommandDefinition";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const cerebrasAuth = async (args: string[]) => {
+  const apiKey = args[0];
+  if (!apiKey) {
+    updateOutput("error", "No API key specified (Cerebras)");
+    return;
+  }
+  await UpdateSettings({ cerebras_api_key: apiKey });
+  updateOutput("log", "✓ Cerebras API key set");
+  await CerebrasClient.syncCerebrasModels();
+  updateOutput("log", "✓ Cerebras models synced");
+};
+
+const cerebrasAuthCommand: Command = {
+  name: "auth",
+  description: "Set Cerebras API key",
+  usage: "/cerebras auth <api-key>",
+  action: cerebrasAuth,
+};
+
+export default cerebrasAuthCommand;

package/src/commands/cerebras/index.ts

@@ -0,0 +1,31 @@
+import type { Command } from "@/types/CommandDefinition";
+import cerebrasAuthCommand from "./auth";
+
+import useFraudeStore from "@/store/useFraudeStore";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const cerebrasCommands: Command = {
+  name: "cerebras",
+  description: "Manage Cerebras models",
+  usage: "/cerebras <subcommand>",
+  action: async (args: string[]) => {
+    if (args.length === 0 || args[0] === "list" || args[0] === "models") {
+      updateOutput("settings", "/models:cerebras");
+      return;
+    }
+  },
+  subcommands: [
+    cerebrasAuthCommand,
+    {
+      name: "list",
+      description: "List Cerebras models",
+      usage: "/cerebras list",
+      action: async () => {
+        updateOutput("settings", "/models:cerebras");
+      },
+    },
+  ],
+};
+
+export default cerebrasCommands;

package/src/commands/forget.ts

@@ -0,0 +1,29 @@
+import type { Command } from "@/types/CommandDefinition";
+import AgentCognition from "@/utils/agentCognition";
+import { resetLSPClient } from "@/utils/lspClient";
+import useFraudeStore from "@/store/useFraudeStore";
+
+const forgetCommand: Command = {
+  name: "forget",
+  description: "Reset the knowledge graph (clears all memories and embeddings)",
+  usage: "/forget",
+  action: async () => {
+    const { updateOutput } = useFraudeStore.getState();
+    try {
+      updateOutput("log", "Resetting knowledge graph and LSP cache...");
+
+      const cognition = AgentCognition.getInstance();
+      await cognition.reset();
+      resetLSPClient();
+
+      updateOutput(
+        "done",
+        "Knowledge graph has been successfully reset. All memories contain data for the current session only.",
+      );
+    } catch (error) {
+      updateOutput("error", `Error resetting knowledge graph: ${error}`);
+    }
+  },
+};
+
+export default forgetCommand;

package/src/commands/google/auth.ts

@@ -0,0 +1,24 @@
+import { UpdateSettings } from "src/config/settings";
+import useFraudeStore from "src/store/useFraudeStore";
+import type { Command } from "@/types/CommandDefinition";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const googleAuth = async (args: string[]) => {
+  const apiKey = args[0];
+  if (!apiKey) {
+    updateOutput("error", "No API key specified (Google)");
+    return;
+  }
+  await UpdateSettings({ google_api_key: apiKey });
+  updateOutput("log", "✓ Google API key set");
+};
+
+const googleAuthCommand: Command = {
+  name: "auth",
+  description: "Set Google API key",
+  usage: "/google auth <api-key>",
+  action: googleAuth,
+};
+
+export default googleAuthCommand;

package/src/commands/google/index.ts

@@ -0,0 +1,31 @@
+import type { Command } from "@/types/CommandDefinition";
+import googleAuthCommand from "./auth";
+
+import useFraudeStore from "@/store/useFraudeStore";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const googleCommands: Command = {
+  name: "google",
+  description: "Manage Google models",
+  usage: "/google <subcommand>",
+  action: async (args: string[]) => {
+    if (args.length === 0 || args[0] === "list" || args[0] === "models") {
+      updateOutput("settings", "/models:google");
+      return;
+    }
+  },
+  subcommands: [
+    googleAuthCommand,
+    {
+      name: "list",
+      description: "List Google models",
+      usage: "/google list",
+      action: async () => {
+        updateOutput("settings", "/models:google");
+      },
+    },
+  ],
+};
+
+export default googleCommands;