fraude-code 0.1.0

package/src/config/settings.ts

@@ -0,0 +1,229 @@
+import { z } from "zod";
+import log from "../utils/logger";
+import { join } from "path";
+import { rename, mkdir } from "fs/promises";
+import { getConfigDir } from "../utils/paths";
+import { ModelSchema, parseModelUniqueId } from "../types/Model";
+import type { TokenUsage } from "@/types/TokenUsage";
+import useSettingsStore from "@/store/useSettingsStore";
+import { SettingsSchema, type Config } from "./schema";
+import useFraudeStore from "@/store/useFraudeStore";
+
+class Settings {
+  private static instance: Settings | null = null;
+  private settingsDir: string;
+  private settings: Config;
+  private writePromise: Promise<void> = Promise.resolve(); // Chain writes to prevent race conditions
+
+  private constructor(config: Config, configDir: string) {
+    this.settings = config;
+    log("Settings loaded:", JSON.stringify(this.settings, null, 2));
+    this.settingsDir = configDir;
+  }
+
+  /**
+   * Initialize the Settings singleton. Call this once at app startup.
+   */
+  static async init(): Promise<Settings> {
+    if (Settings.instance) {
+      return Settings.instance;
+    }
+
+    const configDir = getConfigDir("fraude-code");
+    const config = await Settings.loadFromDisk(configDir);
+    Settings.instance = new Settings(config, configDir);
+    return Settings.instance;
+  }
+
+  /**
+   * Get the Settings instance. Throws if init() hasn't been called.
+   */
+  static getInstance(): Settings {
+    if (!Settings.instance) {
+      throw new Error("Settings not initialized. Call Settings.init() first.");
+    }
+    return Settings.instance;
+  }
+
+  /**
+   * Get a specific setting value.
+   */
+  get<K extends keyof Config>(key: K): Config[K] {
+    return this.settings[key];
+  }
+
+  /**
+   * Get all settings.
+   */
+  getAll(): Config {
+    return { ...this.settings };
+  }
+
+  /**
+   * Update settings and persist to disk.
+   */
+  async set<K extends keyof Config>(key: K, value: Config[K]): Promise<void> {
+    this.settings[key] = value;
+    await this.saveToDisk();
+  }
+
+  /**
+   * Update multiple settings at once and persist to disk (single write).
+   */
+  async setMultiple(updates: Partial<Config>): Promise<void> {
+    for (const [key, value] of Object.entries(updates)) {
+      (this.settings as any)[key] = value;
+    }
+    await this.saveToDisk();
+  }
+
+  /**
+   * Load settings from disk (static, used during initialization).
+   */
+  private static async loadFromDisk(configDir: string): Promise<Config> {
+    try {
+      const settingsPath = join(configDir, "settings.json");
+      const file = Bun.file(settingsPath);
+
+      if (!(await file.exists())) {
+        return SettingsSchema.parse({}); // Return defaults
+      }
+
+      const rawData = await file.json();
+      const result = SettingsSchema.safeParse(rawData);
+
+      if (!result.success) {
+        console.error(
+          "Invalid settings found, attempting to merge with defaults:",
+          result.error.format(),
+        );
+
+        // Backup the invalid settings file just in case
+        try {
+          await Bun.write(
+            `${settingsPath}.bak`,
+            JSON.stringify(rawData, null, 2),
+          );
+          useFraudeStore
+            .getState()
+            .updateOutput(
+              "log",
+              `Backed up invalid settings to ${settingsPath}.bak`,
+            );
+        } catch (backupError) {
+          useFraudeStore
+            .getState()
+            .updateOutput("error", "Failed to backup settings:" + backupError);
+        }
+
+        // Return a merge of defaults and raw data to preserve what we can
+        // We ensure critical fields like 'models' are at least the right type
+        const defaults = SettingsSchema.parse({});
+        const merged = { ...defaults, ...rawData };
+
+        // Safety checks for critical types to prevent runtime crashes
+        if (!Array.isArray(merged.models)) merged.models = defaults.models;
+        if (!Array.isArray(merged.history)) merged.history = defaults.history;
+
+        return merged as Config;
+      }
+
+      return result.data;
+    } catch (e) {
+      useFraudeStore
+        .getState()
+        .updateOutput("error", "Error loading settings:" + e);
+      return SettingsSchema.parse({});
+    }
+  }
+
+  /**
+   * Save current settings to disk atomically.
+   * Writes are chained to prevent race conditions.
+   */
+  private async saveToDisk(): Promise<void> {
+    // Chain this write after any pending write completes
+    const doWrite = async () => {
+      const settingsPath = join(this.settingsDir, "settings.json");
+      const tempPath = `${settingsPath}.tmp`;
+      const content = JSON.stringify(this.settings, null, 2);
+
+      // Ensure the directory exists
+      await mkdir(this.settingsDir, { recursive: true });
+
+      await Bun.write(tempPath, content);
+      await rename(tempPath, settingsPath);
+    };
+
+    // Queue this write after the previous one (even if it failed)
+    this.writePromise = this.writePromise.then(doWrite, doWrite);
+    await this.writePromise;
+  }
+}
+
+const UpdateSettings = async (updates: Partial<Config>) => {
+  await Settings.getInstance().setMultiple(updates);
+  useSettingsStore.setState({ ...updates });
+};
+
+const addHistory = async (value: string) => {
+  const history = Settings.getInstance().get("history");
+  if (value.trim().toLowerCase() != history[0]?.trim().toLowerCase()) {
+    const newHistory = [value, ...history].slice(0, 50);
+    await UpdateSettings({ history: newHistory });
+  }
+};
+
+/**
+ * Increment token usage for a specific model.
+ * @param modelIdentifier - The model identifier (can be unique ID "name|type" or just "name")
+ * @param usage - Token usage data with prompt, completion, and total counts
+ */
+const incrementModelUsage = async (
+  modelIdentifier: string,
+  usage: TokenUsage,
+): Promise<void> => {
+  if (usage.totalTokens <= 0) return;
+
+  const settings = Settings.getInstance();
+  const models = [...settings.get("models")];
+
+  // Try parsing as unique ID (name|type format)
+  const parsed = parseModelUniqueId(modelIdentifier);
+  let modelIndex: number;
+
+  if (parsed) {
+    // Match by both name and type
+    modelIndex = models.findIndex(
+      (m) => m.name === parsed.name && m.type === parsed.type,
+    );
+  } else {
+    // Fall back to name-only matching (legacy format)
+    modelIndex = models.findIndex((m) => m.name === modelIdentifier);
+  }
+
+  if (modelIndex !== -1) {
+    const model = models[modelIndex]!;
+    models[modelIndex] = {
+      ...model,
+      usage: {
+        promptTokens: (model.usage?.promptTokens ?? 0) + usage.promptTokens,
+        completionTokens:
+          (model.usage?.completionTokens ?? 0) + usage.completionTokens,
+        totalTokens: (model.usage?.totalTokens ?? 0) + usage.totalTokens,
+      },
+    };
+    // log(JSON.stringify(models, null, 2));
+    await UpdateSettings({ models });
+  }
+};
+
+export default Settings;
+
+export {
+  Settings,
+  type Config,
+  UpdateSettings,
+  addHistory,
+  incrementModelUsage,
+};

package/src/index.tsx

@@ -0,0 +1,100 @@
+#!/usr/bin/env bun
+
+import { render } from "ink";
+import App from "./components/App";
+import log, { resetLog } from "./utils/logger";
+import { Settings } from "./config/settings";
+import useSettingsStore from "./store/useSettingsStore";
+import OllamaClient from "@/services/ollama";
+import MistralClient from "@/services/mistral";
+import CerebrasClient from "@/services/cerebras";
+import GoogleClient from "@/services/google";
+import CommandCenter from "@/commands";
+import { getKnowledgeOrchestrator } from "@/services/knowledgeOrchestrator";
+
+// Global error handlers to catch and suppress AbortErrors
+process.on("unhandledRejection", (reason) => {
+  // Suppress AbortErrors - they're expected when cancelling operations
+  if (
+    reason instanceof Error &&
+    (reason.name === "AbortError" ||
+      reason.message === "The operation was aborted.")
+  ) {
+    return;
+  }
+  // For DOMException AbortError (code 20)
+  if (
+    reason &&
+    typeof reason === "object" &&
+    "code" in reason &&
+    reason.code === 20
+  ) {
+    return;
+  }
+  console.error("Unhandled rejection:", reason);
+});
+
+process.on("uncaughtException", (error) => {
+  // Suppress AbortErrors
+  if (
+    error.name === "AbortError" ||
+    error.message === "The operation was aborted."
+  ) {
+    return;
+  }
+  console.error("Uncaught exception:", error);
+  process.exit(1);
+});
+
+const syncModels = async () => {
+  await OllamaClient.syncOllamaModels();
+  await MistralClient.syncMistralModels();
+  await CerebrasClient.syncCerebrasModels();
+  await GoogleClient.syncGoogleModels();
+};
+
+async function main() {
+  resetLog();
+  console.clear();
+
+  try {
+    const envFile = Bun.file(".env");
+    if (await envFile.exists()) {
+      const envText = await envFile.text();
+      const lines = envText.split("\n");
+      for (const line of lines) {
+        const [key, ...valueParts] = line.trim().split("=");
+        if (key && !key.startsWith("#") && valueParts.length > 0) {
+          const value = valueParts.join("=").replace(/^["']|["']$/g, "");
+          process.env[key.trim()] = value;
+          log(`Loaded env var: ${key.trim()}`);
+        }
+      }
+    }
+  } catch (e) {
+    log(`Failed to load .env file: ${e}`);
+  }
+
+  await Settings.init();
+  useSettingsStore.getState().syncWithSettings();
+  await CommandCenter.loadPlugins();
+  syncModels();
+  const { waitUntilExit } = render(<App />, { exitOnCtrlC: false });
+
+  // Background index the project (fire-and-forget)
+  getKnowledgeOrchestrator()
+    .indexProject(process.cwd())
+    .catch((e: Error) => log(`Background indexing failed: ${e}`));
+
+  // Handle graceful exit
+  const exitHandler = () => {
+    process.exit(0);
+  };
+
+  process.on("SIGTERM", exitHandler);
+
+  await waitUntilExit();
+  process.exit(0);
+}
+
+main();

package/src/providers/providers.ts

@@ -0,0 +1,71 @@
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { createGroq } from "@ai-sdk/groq";
+import { createOllama } from "ollama-ai-provider-v2";
+import { createCerebras } from "@ai-sdk/cerebras";
+import { createMistral } from "@ai-sdk/mistral";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import useSettingsStore from "@/store/useSettingsStore";
+import { parseModelUniqueId } from "@/types/Model";
+
+const getSettings = () => useSettingsStore.getState();
+
+/**
+ * Get the provider type and actual model name from a model identifier.
+ * Supports both:
+ * - Unique ID format: "modelName|type" (e.g., "openai/gpt-oss-120b|openrouter")
+ * - Legacy name-only format: "modelName" (e.g., "openai/gpt-oss-120b")
+ */
+const getProviderForModel = (
+  modelIdentifier: string,
+): { name: string; type: string } => {
+  // Try parsing as unique ID (name|type format)
+  const parsed = parseModelUniqueId(modelIdentifier);
+  if (parsed) {
+    return parsed;
+  }
+
+  // Fall back to name-only lookup for backwards compatibility
+  const { models } = getSettings();
+  const model = models.find((m) => m.name === modelIdentifier);
+  if (!model) throw new Error(`Model not found: ${modelIdentifier}`);
+  return { name: model.name, type: model.type };
+};
+
+export function getModel(modelIdentifier: string) {
+  const { name, type } = getProviderForModel(modelIdentifier);
+  switch (type) {
+    case "groq":
+      const groq = createGroq({
+        apiKey: getSettings().groq_api_key || process.env.GROQ_API_KEY,
+      });
+      return groq(name);
+    case "ollama":
+      const ollama = createOllama({
+        baseURL: `${getSettings().ollamaUrl || process.env.OLLAMA_URL || "http://localhost:11434"}/api`,
+      });
+      return ollama(name);
+    case "openrouter":
+      const openrouter = createOpenRouter({
+        apiKey:
+          getSettings().openrouter_api_key || process.env.OPENROUTER_API_KEY,
+      });
+      return openrouter(name);
+    case "cerebras":
+      const cerebras = createCerebras({
+        apiKey: getSettings().cerebras_api_key || process.env.CEREBRAS_API_KEY,
+      });
+      return cerebras(name);
+    case "mistral":
+      const mistral = createMistral({
+        apiKey: getSettings().mistral_api_key || process.env.MISTRAL_API_KEY,
+      });
+      return mistral(name);
+    case "google":
+      const google = createGoogleGenerativeAI({
+        apiKey: getSettings().google_api_key || process.env.GOOGLE_API_KEY,
+      });
+      return google(name);
+    default:
+      throw new Error(`Unknown provider: ${type}`);
+  }
+}

package/src/services/PluginLoader.ts

@@ -0,0 +1,123 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import type { Command } from "@/types/CommandDefinition";
+import log from "@/utils/logger";
+import { Settings, UpdateSettings } from "@/config/settings";
+import { BunApiRouter } from "@/utils/router";
+import useFraudeStore from "@/store/useFraudeStore";
+import type { PluginContext } from "@/types/PluginContext";
+import Agent from "@/agent/agent";
+
+export class PluginLoader {
+  private pluginsDirs: string[];
+
+  constructor() {
+    // Get the system-wide config directory
+    const configDir = (Settings as any).instance
+      ? Settings.getInstance().getAll()
+        ? (Settings as any).instance.settingsDir
+        : ""
+      : "";
+
+    this.pluginsDirs = [
+      path.resolve(import.meta.dir, "../../plugins"), // Plugin folder in the source/package root
+      path.resolve(process.cwd(), ".fraude", "plugins"), // Local plugins in the current working directory
+      path.resolve(os.homedir(), "fraude", "plugins"), // Global plugins in the home directory
+    ];
+
+    if (configDir) {
+      this.pluginsDirs.push(path.join(configDir, "plugins")); // Global system config plugins
+    }
+
+    // Add any plugins folder relative to the executable if not already covered
+    const execPath = process.argv[1];
+    if (execPath) {
+      const execDir = path.dirname(execPath);
+      if (execDir !== process.cwd()) {
+        this.pluginsDirs.push(path.resolve(execDir, "./plugins"));
+      }
+    }
+
+    // De-duplicate paths
+    this.pluginsDirs = Array.from(new Set(this.pluginsDirs));
+  }
+
+  async loadPlugins(): Promise<Command[]> {
+    const allCommands: Command[] = [];
+    const loadedPluginNames = new Set<string>();
+
+    const context: PluginContext = {
+      log: log,
+      Router: BunApiRouter,
+      router: BunApiRouter.shared,
+      Agent: Agent,
+      settings: {
+        get: (key) => Settings.getInstance().get(key as any),
+        getAll: () => Settings.getInstance().getAll(),
+        update: async (updates) => {
+          await UpdateSettings(updates);
+        },
+      },
+      ui: {
+        updateOutput: (type, content) =>
+          useFraudeStore.getState().updateOutput(type, content),
+      },
+      utils: {},
+    };
+
+    for (const dir of this.pluginsDirs) {
+      try {
+        await fs.access(dir);
+      } catch {
+        continue;
+      }
+
+      log(`Searching for plugins in: ${dir}`);
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (loadedPluginNames.has(entry.name)) continue;
+
+          const pluginPath = path.join(dir, entry.name);
+          const entryPoint = path.join(pluginPath, "index.ts");
+
+          try {
+            await fs.access(entryPoint);
+            const pluginModule = await import(entryPoint);
+
+            if (pluginModule.default) {
+              let commands: Command | Command[];
+
+              if (typeof pluginModule.default === "function") {
+                // Context-aware plugin
+                commands = await pluginModule.default(context);
+              } else {
+                // Legacy static object plugin
+                commands = pluginModule.default;
+              }
+
+              if (Array.isArray(commands)) {
+                allCommands.push(...commands);
+              } else {
+                allCommands.push(commands);
+              }
+              loadedPluginNames.add(entry.name);
+              log(`Loaded plugin: ${entry.name} from ${dir}`);
+            }
+          } catch (e) {
+            // Only log error if index.ts exists but failed to load
+            try {
+              await fs.access(entryPoint);
+              log(`Failed to load plugin ${entry.name}:`, e);
+            } catch {
+              // index.ts doesn't exist, ignore
+            }
+          }
+        }
+      }
+    }
+    return allCommands;
+  }
+}

package/src/services/cerebras.ts

@@ -0,0 +1,69 @@
+import { UpdateSettings } from "@/config/settings";
+import useSettingsStore from "../store/useSettingsStore";
+import type { Model } from "../types/Model";
+
+const getSettings = () => useSettingsStore.getState();
+
+interface CerebrasModelsResponse {
+  object: string;
+  data: CerebrasModel[];
+}
+
+interface CerebrasModel {
+  id: string;
+  object: string;
+  created: number;
+  owned_by: string;
+}
+
+class CerebrasClient {
+  async syncCerebrasModels() {
+    const apiKey =
+      getSettings().cerebras_api_key || process.env.CEREBRAS_API_KEY;
+    if (!apiKey) {
+      return;
+    }
+    const url = `https://api.cerebras.ai/v1/models`;
+    const options = {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` },
+    };
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch Cerebras models ${response.status}`);
+    }
+    const data = (await response.json()) as CerebrasModelsResponse;
+    const savedModels = getSettings().models;
+    const existingCerebrasModels = savedModels.filter(
+      (m) => m.type === "cerebras",
+    );
+    const otherModels = savedModels.filter((m) => m.type !== "cerebras");
+
+    const models: Model[] = data.data.map((model) => {
+      const existing = existingCerebrasModels.find((m) => m.name === model.id);
+      return {
+        type: "cerebras",
+        name: model.id,
+        modified_at: new Date(model.created * 1000).toISOString(),
+        digest: existing?.digest || "",
+        usage: existing?.usage || {
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0,
+        },
+        details: {
+          provider: "cerebras",
+          ...existing?.details,
+        },
+      } as Model;
+    });
+
+    // Merge: keep all other models, and replace/add the synced cerebras models
+    // Note: This effectively removes local cerebras models that are no longer returned by the API.
+    // If we want to keep them, we should change logic. But usually sync reflects source of truth.
+    const mergedModels = [...otherModels, ...models];
+    await UpdateSettings({ models: mergedModels });
+  }
+}
+
+export default new CerebrasClient();