fraude-code 0.1.0

package/src/utils/paths.ts

@@ -0,0 +1,24 @@
+import { platform, homedir } from "os";
+import { join } from "path";
+
+export function getConfigDir(appName: string): string {
+  const osPlatform = platform();
+  const home = homedir();
+
+  switch (osPlatform) {
+    case "win32":
+      return join(
+        process.env.APPDATA || join(home, "AppData", "Roaming"),
+        appName,
+      );
+    case "darwin":
+      return join(home, "Library", "Application Support", appName);
+    case "linux":
+      return join(
+        process.env.XDG_CONFIG_HOME || join(home, ".config"),
+        appName,
+      );
+    default:
+      return join(home, `.${appName}`);
+  }
+}

package/src/utils/queryHandler.ts

@@ -0,0 +1,227 @@
+import useFraudeStore from "@/store/useFraudeStore";
+import CommandCenter from "@/commands";
+import log from "./logger";
+import { resetStreamState } from "./streamHandler";
+import pendingChanges from "@/agent/pendingChanges";
+import { getManagerAgent } from "@/agent/subagents/managerAgent";
+import {
+  getNextTodo,
+  getTodoById,
+  hasPendingTodos,
+} from "@/agent/tools/todoTool";
+import { getWorkerSubAgent } from "@/agent/subagents/workerSubAgent";
+import { getReviewerSubAgent } from "@/agent/subagents/reviewerSubAgent";
+import type { TodoItem } from "@/agent/tools/todoTool";
+import getFastAgent from "@/agent/subagents/fastAgent";
+import getAskAgent from "@/agent/subagents/askAgent";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const checkAbort = () => {
+  const abortController = useFraudeStore.getState().abortController;
+  if (abortController?.signal.aborted) {
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    throw error;
+  }
+};
+
+const getTaskContext = (task: TodoItem) => {
+  const context = task.context;
+  const notes = task.notes;
+
+  return `Task: ${task.description}
+
+  Task ID: ${task.id}
+
+Context:
+${context ? `Files: ${context.files.map((f) => "`" + f + "`").join(", ")} \nInstructions: ${context.instructions}` : "No pre-researched context provided."}
+
+Notes:
+${notes.length > 0 ? notes.map((n, i) => `${i + 1}. ${n}`).join("\n") : "None"}`;
+};
+
+const fastMode = async (query: string) => {
+  const abortController = useFraudeStore.getState().abortController;
+  if (!abortController) {
+    throw new Error("No abort controller found");
+  }
+  const response = await getFastAgent().stream(query, {
+    abortSignal: abortController.signal,
+  });
+  checkAbort();
+
+  log("Fast Agent Response:");
+  log(JSON.stringify(response, null, 2));
+};
+
+const planMode = async (query: string) => {
+  const abortController = useFraudeStore.getState().abortController;
+  if (!abortController) {
+    throw new Error("No abort controller found");
+  }
+  const response = await getManagerAgent().stream(query, {
+    abortSignal: abortController.signal,
+  });
+  checkAbort();
+
+  log("Manager Response:");
+  log(JSON.stringify(response, null, 2));
+
+  let nextTask = await getNextTodo();
+  while (!nextTask.done && nextTask.task) {
+    checkAbort();
+
+    let taskContext = getTaskContext(nextTask.task);
+    updateOutput("log", "Working on task: " + nextTask.task.description);
+    const response = await getWorkerSubAgent().stream(taskContext, {
+      abortSignal: abortController.signal,
+    });
+    checkAbort();
+
+    log("Worker Response:");
+    log(JSON.stringify(response, null, 2));
+    const taskAfterWorker = await getTodoById(nextTask.task.id);
+    if (taskAfterWorker && taskAfterWorker.status === "in-progress") {
+      log(
+        "Worker finished but didn't update status. Auto-advancing to 'reviewing'.",
+      );
+    }
+
+    const getUpdatedTask = await getTodoById(nextTask.task.id);
+    if (!getUpdatedTask) {
+      updateOutput("error", "Task not found");
+      continue;
+    }
+    taskContext = getTaskContext(getUpdatedTask);
+    updateOutput(
+      "log",
+      "Reviewing changes for task: " + nextTask.task.description,
+    );
+    const reviewResponse = await getReviewerSubAgent().stream(taskContext, {
+      abortSignal: abortController.signal,
+    });
+    checkAbort();
+
+    log("Review Response:");
+    log(JSON.stringify(reviewResponse, null, 2));
+
+    // SAFETY CHECK: Did the reviewer complete the task?
+    const postReviewTask = await getTodoById(nextTask.task.id);
+    if (
+      postReviewTask &&
+      postReviewTask.status !== "completed" &&
+      postReviewTask.status !== "pending"
+    ) {
+      log(
+        "Warning: Reviewer did not complete or reject task. Auto-completing to proceed.",
+      );
+      break;
+    }
+
+    nextTask = await getNextTodo();
+  }
+};
+
+const askMode = async (query: string) => {
+  const abortController = useFraudeStore.getState().abortController;
+  if (!abortController) {
+    throw new Error("No abort controller found");
+  }
+  const response = await getAskAgent().stream(query, {
+    abortSignal: abortController.signal,
+  });
+  checkAbort();
+
+  log("Ask Agent Response:");
+  log(JSON.stringify(response, null, 2));
+};
+
+export default async function QueryHandler(query: string) {
+  if (query === "exit") {
+    process.exit(0);
+  }
+  updateOutput("command", query);
+  if (query.startsWith("/")) {
+    useFraudeStore.setState({
+      status: 2,
+    });
+    await CommandCenter.processCommand(query);
+    useFraudeStore.setState({
+      status: 0,
+    });
+    return;
+  }
+  log(`User Query: ${query}`);
+
+  useFraudeStore.setState({
+    status: 1,
+    elapsedTime: 0,
+    lastBreak: 0,
+    abortController: new AbortController(),
+    statusText: "Pondering",
+  });
+  resetStreamState();
+
+  // Initialize cognition and inject relevant knowledge
+  const contextManager = useFraudeStore.getState().contextManager;
+
+  try {
+    // Prime context with project knowledge (once per session)
+    // await contextManager.primeWithKnowledge();
+
+    // Inject query-specific context via orchestrator
+    await contextManager.injectQueryContext(query);
+  } catch (e) {
+    log(`Knowledge injection failed (non-fatal): ${e}`);
+  }
+
+  try {
+    useFraudeStore.setState({
+      researchCache: {},
+    });
+    if (useFraudeStore.getState().executionMode == 0) {
+      // Fast Mode
+      await fastMode(query);
+    } else if (useFraudeStore.getState().executionMode == 1) {
+      // Planning Mode
+      await planMode(query);
+    } else if (useFraudeStore.getState().executionMode == 2) {
+      // Ask Mode
+      await askMode(query);
+    }
+
+    // Persist session learnings after successful completion
+    try {
+      await contextManager.persistSession();
+    } catch (e) {
+      log(`Session persistence failed (non-fatal): ${e}`);
+    }
+
+    if (pendingChanges.hasChanges()) {
+      useFraudeStore.setState({ status: 3, statusText: "Reviewing Changes" });
+      updateOutput("confirmation", "");
+    } else {
+      updateOutput(
+        "done",
+        `Task Completed in ${(useFraudeStore.getState().elapsedTime / 10).toFixed(1)}s`,
+      );
+    }
+  } catch (e: any) {
+    if (e?.name === "AbortError" || e?.message === "Aborted") {
+      log("Query aborted by user");
+    } else {
+      log(`Error in query handler: ${e?.message}`);
+      throw e; // Re-throw non-abort errors
+    }
+  } finally {
+    // Cleanup unless in reviewing mode
+    if (useFraudeStore.getState().status !== 3) {
+      useFraudeStore.setState({
+        status: 0,
+        abortController: null,
+        statusText: "",
+      });
+    }
+  }
+}

package/src/utils/router.ts

@@ -0,0 +1,278 @@
+import useFraudeStore from "@/store/useFraudeStore";
+import type { Server } from "bun";
+
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+type Handler = (req: Request) => Response | Promise<Response>;
+const { updateOutput } = useFraudeStore.getState();
+
+interface Route {
+  method: HttpMethod;
+  path: string;
+  handler: Handler;
+}
+
+export interface WebSocketHandler {
+  open?: (ws: any) => void;
+  message: (ws: any, message: string) => void;
+  close?: (ws: any) => void;
+}
+
+export class BunApiRouter {
+  private static routers = new Map<string, BunApiRouter>();
+  private static _shared: BunApiRouter;
+
+  public static get shared(): BunApiRouter {
+    if (!this._shared) {
+      this._shared = new BunApiRouter();
+    }
+    return this._shared;
+  }
+
+  public static getRouter(id: string): BunApiRouter | undefined {
+    return this.routers.get(id);
+  }
+  public id: string = crypto.randomUUID();
+  public port: number = 3000;
+  private routes: Route[] = [];
+  private wsRoutes: { path: string; handler: WebSocketHandler }[] = [];
+  private server: Server<any> | null = null;
+  private resolveServicePromise: (() => void) | null = null;
+  public onStop?: () => void;
+
+  public static stopRouter(id: string) {
+    const router = this.routers.get(id);
+    if (router) {
+      router.stop();
+      this.routers.delete(id);
+    }
+  }
+
+  /**
+   * Check if a route pattern matches a given pathname and extract params
+   * Supports dynamic segments like :userId
+   */
+  private getParams(
+    pattern: string,
+    pathname: string,
+  ): Record<string, string> | null {
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = pathname.split("/").filter(Boolean);
+
+    if (patternParts.length !== pathParts.length) {
+      return null;
+    }
+
+    const params: Record<string, string> = {};
+
+    for (let i = 0; i < patternParts.length; i++) {
+      const patternPart = patternParts[i]!;
+      const pathPart = pathParts[i]!;
+
+      if (patternPart.startsWith(":")) {
+        const paramName = patternPart.slice(1);
+        params[paramName] = pathPart;
+      } else if (patternPart !== pathPart) {
+        return null;
+      }
+    }
+
+    return params;
+  }
+
+  /**
+   * Register a new endpoint
+   * @param method HTTP Method
+   * @param path URL path (e.g. "/api/v1/users" or "/users/:id")
+   * @param handler Function to handle the request
+   */
+  public register(
+    method: HttpMethod,
+    path: string,
+    handler: (req: Request & { params: Record<string, string> }) => any,
+  ) {
+    // Check for duplicates
+    const duplicateIndex = this.routes.findIndex(
+      (r) => r.method === method && r.path === path,
+    );
+
+    if (duplicateIndex !== -1) {
+      // Overwrite instead of warning, to allow re-registration during development/re-runs
+      this.routes[duplicateIndex] = { method, path, handler: handler as any };
+      return;
+    }
+
+    this.routes.push({ method, path, handler: handler as any });
+  }
+
+  /**
+   * Register a WebSocket endpoint
+   * @param path URL path
+   * @param handler WebSocket event handlers
+   */
+  public registerWebSocket(path: string, handler: WebSocketHandler) {
+    this.wsRoutes.push({ path, handler });
+  }
+
+  /**
+   * Start the server and block until interrupted.
+   * @param port Port to listen on (default: 3000)
+   */
+  public async serve(port: number = 3000): Promise<void> {
+    if (this.server) {
+      throw new Error(
+        `Router ${this.id} is already serving on port ${this.port}`,
+      );
+    }
+
+    this.port = port;
+
+    // Create a promise that we can manually resolve to "unblock" the caller
+    const servicePromise = new Promise<void>((resolve) => {
+      this.resolveServicePromise = resolve;
+    });
+
+    try {
+      this.server = Bun.serve<{
+        handler: WebSocketHandler;
+        params: Record<string, string>;
+      }>({
+        port,
+        idleTimeout: 180,
+        fetch: async (req, server) => {
+          const url = new URL(req.url);
+
+          // Check for WebSocket upgrade
+          let wsParams: Record<string, string> = {};
+          const wsRoute = this.wsRoutes.find((r) => {
+            const p = this.getParams(r.path, url.pathname);
+            if (p) {
+              wsParams = p;
+              return true;
+            }
+            return false;
+          });
+
+          if (
+            wsRoute &&
+            server.upgrade(req, {
+              data: { handler: wsRoute.handler, params: wsParams },
+            })
+          ) {
+            return undefined;
+          }
+
+          // CORS support
+          const corsHeaders = {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods":
+              "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+          };
+
+          if (req.method === "OPTIONS") {
+            return new Response(null, { headers: corsHeaders });
+          }
+
+          // Default health check
+          if (url.pathname === "/health" && req.method === "GET") {
+            return new Response("OK", { status: 200, headers: corsHeaders });
+          }
+
+          // Find matching route and extract params
+          let params: Record<string, string> = {};
+          const route = this.routes.find((r) => {
+            if (r.method !== req.method) return false;
+            const p = this.getParams(r.path, url.pathname);
+            if (p) {
+              params = p;
+              return true;
+            }
+            return false;
+          });
+
+          if (route) {
+            try {
+              // Attach params to request object
+              (req as any).params = params;
+              const response = await route.handler(req);
+              // Append CORS headers to the handler's response
+              const newHeaders = new Headers(response.headers);
+              Object.entries(corsHeaders).forEach(([key, value]) => {
+                newHeaders.set(key, value);
+              });
+              return new Response(response.body, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: newHeaders,
+              });
+            } catch (error) {
+              console.error("Error in handler:", error);
+              return new Response("Internal Server Error", {
+                status: 500,
+                headers: corsHeaders,
+              });
+            }
+          }
+
+          return new Response("Not Found", {
+            status: 404,
+            headers: corsHeaders,
+          });
+        },
+        websocket: {
+          open(ws) {
+            if (ws.data?.handler?.open) {
+              ws.data.handler.open(ws);
+            }
+          },
+          message(ws, message) {
+            if (ws.data?.handler?.message) {
+              ws.data.handler.message(
+                ws,
+                typeof message === "string" ? message : message.toString(),
+              );
+            }
+          },
+          close(ws) {
+            if (ws.data?.handler?.close) {
+              ws.data.handler.close(ws);
+            }
+          },
+        },
+      });
+
+      // Register this router instance
+      BunApiRouter.routers.set(this.id, this);
+
+      // Output the interactive component
+      updateOutput("interactive-server", this.id);
+
+      // Block until stopped
+      await servicePromise;
+    } catch (error) {
+      updateOutput("error", `Failed to start server: ${error}`);
+      throw error;
+    } finally {
+      // Cleanup
+      if (this.server) {
+        this.server.stop(true); // Forced stop
+        this.server = null;
+      }
+      this.resolveServicePromise = null;
+      BunApiRouter.routers.delete(this.id);
+    }
+  }
+
+  public stop() {
+    if (this.resolveServicePromise) {
+      this.resolveServicePromise();
+      this.resolveServicePromise = null;
+      if (this.onStop) this.onStop();
+    } else if (this.server) {
+      // Fallback if promise was already resolved or cleared but server is somehow active
+      this.server.stop(true);
+      this.server = null;
+      if (this.onStop) this.onStop();
+    }
+  }
+}

package/src/utils/streamHandler.ts

@@ -0,0 +1,132 @@
+import useFraudeStore from "@/store/useFraudeStore";
+import log from "./logger";
+import { UpdateSettings } from "@/config/settings";
+import type { TokenUsage } from "@/types/TokenUsage";
+
+interface StreamState {
+  reasoningText: string;
+  agentText: string;
+  currentToolCallId: string | null;
+  toolCallTimestamps: Map<string, number>;
+}
+
+const state: StreamState = {
+  reasoningText: "",
+  agentText: "",
+  currentToolCallId: null,
+  toolCallTimestamps: new Map(),
+};
+
+function resetState() {
+  state.reasoningText = "";
+  state.agentText = "";
+  state.currentToolCallId = null;
+  state.toolCallTimestamps.clear();
+}
+
+function formatDuration(ms: number): number {
+  return ms / 1000;
+}
+
+export function handleStreamChunk(chunk: Record<string, unknown>): TokenUsage {
+  const { updateOutput } = useFraudeStore.getState();
+  const store = useFraudeStore.getState();
+
+  // log(`Stream chunk: ${JSON.stringify(chunk)}`);
+
+  switch (chunk.type) {
+    case "start":
+      resetState();
+      break;
+
+    case "reasoning-start":
+      state.reasoningText = "";
+      useFraudeStore.setState({ lastBreak: store.elapsedTime });
+      updateOutput("reasoning", "", { dontOverride: true });
+      break;
+
+    case "reasoning-delta":
+      state.reasoningText += chunk.text as string;
+      updateOutput("reasoning", state.reasoningText);
+      break;
+
+    case "reasoning-end": {
+      const elapsed = store.elapsedTime - store.lastBreak;
+      const duration = formatDuration(elapsed * 100);
+      updateOutput("reasoning", `${state.reasoningText}`, { duration });
+      useFraudeStore.setState({ lastBreak: store.elapsedTime });
+      break;
+    }
+
+    case "text-delta":
+      const lastItem = store.outputItems[store.outputItems.length - 1];
+      if (lastItem?.type === "toolCall") {
+        state.agentText = "";
+      }
+      state.agentText += chunk.text as string;
+      updateOutput("agentText", state.agentText);
+      break;
+
+    case "finish-step": {
+      const finishReason = chunk.finishReason as string;
+      if (finishReason === "stop" && state.agentText) {
+        // Final text output is already displayed
+      }
+
+      // Safely extract usage data using AI SDK's normalized format or provider raw format
+      const usage = chunk.usage as
+        | Record<string, number | undefined>
+        | undefined;
+
+      if (usage) {
+        const promptTokens = usage.promptTokens ?? usage.inputTokens ?? 0;
+        const completionTokens =
+          usage.completionTokens ?? usage.outputTokens ?? 0;
+        const totalTokens =
+          usage.totalTokens ?? promptTokens + completionTokens;
+
+        return {
+          promptTokens,
+          completionTokens,
+          totalTokens,
+        };
+      }
+
+      // Return zero usage if not available
+      return {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+      };
+    }
+
+    case "finish": {
+      // const elapsed = store.elapsedTime;
+      // updateOutput(
+      //   "done",
+      //   `Finished in ${formatDuration(elapsed * 100).toFixed(1)}s`,
+      // );
+      resetState();
+      break;
+    }
+
+    case "error": {
+      const error = chunk.error as Error;
+      updateOutput("error", error.message);
+      break;
+    }
+
+    default:
+      // Ignore other chunk types (start-step, tool-input-*, etc.)
+      break;
+  }
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+  };
+}
+
+export function resetStreamState() {
+  resetState();
+}