fraude-code 0.1.0

package/src/commands/groq/add_model.ts

@@ -0,0 +1,60 @@
+import GroqClient from "@/services/groq";
+import type { Model } from "@/types/Model";
+import useSettingsStore from "@/store/useSettingsStore";
+import { UpdateSettings } from "src/config/settings";
+import useFraudeStore from "src/store/useFraudeStore";
+import type { Command } from "@/types/CommandDefinition";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const addGroqModel = async (args: string[]) => {
+  const model = args[0];
+  if (!model) {
+    updateOutput("error", "No model specified (Groq)");
+    return;
+  }
+  const modelData: any = await GroqClient.getModelData(model);
+
+  if (!modelData) {
+    throw new Error(`No data found for Groq model ${model}`);
+  }
+
+  const newModel: Model = {
+    type: "groq",
+    name: model,
+    modified_at: new Date(modelData.created * 1000).toISOString(),
+    digest: modelData.id,
+    capabilities: [],
+    usage: {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+    },
+    details: {
+      context_length: modelData.context_window,
+    },
+  };
+
+  const savedModels = useSettingsStore.getState().models || [];
+
+  const existingIndex = savedModels.findIndex(
+    (m) => m.name === newModel.name && m.type === "groq",
+  );
+
+  if (existingIndex >= 0) {
+    savedModels[existingIndex] = newModel;
+  } else {
+    savedModels.push(newModel);
+  }
+  await UpdateSettings({ models: savedModels });
+  updateOutput("log", "Groq model added: " + model);
+};
+
+const addGroqModelCommand: Command = {
+  name: "add",
+  description: "Add a Groq model",
+  usage: "/groq add <model-name>",
+  action: addGroqModel,
+};
+
+export default addGroqModelCommand;

package/src/commands/groq/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 groqAuth = async (args: string[]) => {
+  const apiKey = args[0];
+  if (!apiKey) {
+    updateOutput("error", "No API key specified (Groq)");
+    return;
+  }
+  await UpdateSettings({ groq_api_key: apiKey });
+  updateOutput("log", "Groq API key set");
+};
+
+const groqAuthCommand: Command = {
+  name: "auth",
+  description: "Set Groq API key",
+  usage: "/groq auth <api-key>",
+  action: groqAuth,
+};
+
+export default groqAuthCommand;

package/src/commands/groq/index.ts

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

package/src/commands/index.ts

@@ -0,0 +1,65 @@
+import type { Command } from "@/types/CommandDefinition";
+import COMMANDS from "./COMMANDS";
+import log from "@/utils/logger";
+
+// Class for handling commands
+class CommandCenter {
+  private commands: Command[] = [];
+
+  constructor() {
+    this.commands = COMMANDS;
+  }
+
+  async loadPlugins() {
+    try {
+      const { PluginLoader } = await import("@/services/PluginLoader");
+      const loader = new PluginLoader();
+      const pluginCommands = await loader.loadPlugins();
+      this.commands = [...this.commands, ...pluginCommands];
+      log(`Loaded ${pluginCommands.length} plugin commands.`);
+    } catch (error) {
+      log("Error loading plugins:", error);
+    }
+  }
+
+  processCommand = async (query: string) => {
+    let command = query.slice(1).split(" ");
+    const base = command.shift();
+
+    for (const cmd of this.commands) {
+      if (cmd.name === base) {
+        if (cmd.subcommands) {
+          for (const sub of cmd.subcommands) {
+            if (sub.name === command[0]) {
+              if (sub.action) return await sub.action(command.slice(1));
+            }
+          }
+          // If no subcommand matched, use the base command's action if it exists
+          if (cmd.action) return await cmd.action(command);
+        } else {
+          if (cmd.action) return await cmd.action(command);
+        }
+      }
+    }
+  };
+
+  getAllCommands(): Command[] {
+    const templates: Command[] = [];
+
+    for (const cmd of this.commands) {
+      if (cmd.usage && !cmd.usage.includes("<subcommand>")) {
+        templates.push(cmd);
+      }
+      // Add subcommands
+      if (cmd.subcommands) {
+        for (const sub of cmd.subcommands) {
+          templates.push(sub);
+        }
+      }
+    }
+
+    return templates;
+  }
+}
+
+export default new CommandCenter();

package/src/commands/knowledge.ts

@@ -0,0 +1,92 @@
+import type { Command } from "@/types/CommandDefinition";
+import useFraudeStore from "@/store/useFraudeStore";
+import AgentCognition from "@/utils/agentCognition";
+import type { KnowledgeViewData } from "@/components/output/KnowledgeView";
+
+const action = async (args: string[]) => {
+  const { updateOutput } = useFraudeStore.getState();
+
+  try {
+    const cognition = AgentCognition.getInstance();
+    await cognition.init();
+
+    if (args.length === 0) {
+      // Show summary of all knowledge
+      const [decisions, facts, concepts, references] = await Promise.all([
+        cognition.findByType("decision"),
+        cognition.findByType("fact"),
+        cognition.findByType("concept"),
+        cognition.findByType("reference"),
+        // cognition.findByType("summary"),
+      ]);
+
+      const total =
+        decisions.length + facts.length + concepts.length + references.length;
+      // + summaries.length;
+
+      if (total === 0) {
+        const data: KnowledgeViewData = { mode: "empty" };
+        updateOutput("knowledge", JSON.stringify(data));
+        return;
+      }
+
+      const data: KnowledgeViewData = {
+        mode: "summary",
+        data: {
+          decisions: decisions.map((d) => ({
+            content: d.content,
+            type: d.type,
+          })),
+          facts: facts.map((f) => ({ content: f.content, type: f.type })),
+          concepts: concepts.map((c) => ({
+            content: c.content,
+            type: c.type,
+          })),
+          references: references.map((r) => ({
+            content: r.content,
+            type: r.type,
+          })),
+          // summaries: summaries.map((s) => ({
+          //   content: s.content,
+          //   type: s.type,
+          // })),
+        },
+      };
+
+      updateOutput("knowledge", JSON.stringify(data));
+    } else {
+      // Search knowledge
+      const query = args.join(" ");
+      const results = await cognition.retrieveRelevant(query, 10);
+
+      const data: KnowledgeViewData = {
+        mode: "search",
+        data: {
+          query,
+          results: results.map((r) => ({ content: r.content, type: r.type })),
+        },
+      };
+
+      updateOutput("knowledge", JSON.stringify(data));
+    }
+  } catch (e) {
+    updateOutput("error", `Failed to retrieve knowledge: ${e}`);
+  }
+};
+
+const knowledgeCommand: Command = {
+  name: "knowledge",
+  description: "View or search stored project knowledge",
+  usage: "/knowledge",
+  action,
+  subcommands: [
+    {
+      name: "search",
+      description: "Search stored project knowledge",
+      usage: "/knowledge search <query>",
+      action,
+    },
+  ],
+};
+
+export default knowledgeCommand;

package/src/commands/log.ts

@@ -0,0 +1,32 @@
+import fs from "fs";
+import path from "path";
+import type { Command } from "@/types/CommandDefinition";
+import { getLogPath } from "@/utils/logger";
+import useFraudeStore from "@/store/useFraudeStore";
+
+const logCommand: Command = {
+  name: "log",
+  description: "Save log for current session to local directory",
+  usage: "/log",
+  action: async () => {
+    const { updateOutput } = useFraudeStore.getState();
+    try {
+      const sourcePath = getLogPath();
+      const destPath = path.join(process.cwd(), "debug.log");
+
+      if (fs.existsSync(sourcePath)) {
+        fs.copyFileSync(sourcePath, destPath);
+        updateOutput(
+          "log",
+          `Debug log for current session written to ${destPath}`,
+        );
+      } else {
+        updateOutput("log", "No debug log found.");
+      }
+    } catch (error) {
+      updateOutput("error", `Error writing debug log: ${error}`);
+    }
+  },
+};
+
+export default logCommand;

package/src/commands/mistral/auth.ts

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

package/src/commands/mistral/index.ts

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

package/src/commands/model/index.ts

@@ -0,0 +1,145 @@
+import type { Command } from "@/types/CommandDefinition";
+import useSettingsStore from "@/store/useSettingsStore";
+import { UpdateSettings } from "@/config/settings";
+import {
+  parseModelDisplayId,
+  getModelDisplayId,
+  getModelUniqueId,
+} from "@/types/Model";
+import useFraudeStore from "@/store/useFraudeStore";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const setModel = async (args: string[]) => {
+  const store = useSettingsStore.getState();
+  const models = store.models;
+
+  const subcommand = args[0]?.toLowerCase() ?? "";
+
+  // Role aliases
+  const roleAliases: Record<string, string> = {
+    p: "primary",
+    primary: "primary",
+    s: "secondary",
+    secondary: "secondary",
+    a: "all",
+    all: "all",
+  };
+
+  // Check if first arg is a role command
+  const roleCommands = ["all", "primary", "secondary", "p", "s", "a"];
+
+  let modelName: string;
+  let role: string;
+
+  if (subcommand && roleCommands.includes(subcommand)) {
+    // Format: /model <role> <model-name>
+    role = roleAliases[subcommand] ?? subcommand;
+    modelName = args.slice(1).join(" ");
+  } else {
+    // Format: /model <model-name> [role]
+    // Check if last arg is a role
+    const lastArg = args[args.length - 1]?.toLowerCase() ?? "";
+    if (args.length > 1 && lastArg && roleAliases[lastArg]) {
+      role = roleAliases[lastArg];
+      modelName = args.slice(0, -1).join(" ");
+    } else {
+      role = "all";
+      modelName = args.join(" ");
+    }
+  }
+  if (!modelName) {
+    updateOutput(
+      "log",
+      "Error: No model name specified. Use /model list to see current assignments.",
+    );
+    return;
+  }
+
+  // Try to parse as display ID (e.g., "model-name (provider)")
+  const parsed = parseModelDisplayId(modelName);
+  let matchedModel;
+
+  if (parsed) {
+    // Match by both name and provider type
+    matchedModel = models.find(
+      (m) =>
+        m.name.toLowerCase() === parsed.name.toLowerCase() &&
+        m.type === parsed.type,
+    );
+  } else {
+    // Fall back to name-only matching (for backwards compatibility)
+    // If multiple models have the same name, this picks the first one
+    matchedModel = models.find(
+      (m) => m.name.toLowerCase() === modelName.toLowerCase(),
+    );
+  }
+
+  if (!matchedModel) {
+    updateOutput(
+      "error",
+      `Error: Model "${modelName}" not found. Use /model list to see available models.`,
+    );
+    return;
+  }
+
+  // Use unique ID (name|type) for storage to distinguish same-named models
+  const finalModelName = getModelUniqueId(matchedModel);
+  const displayName = getModelDisplayId(matchedModel);
+  const changedRoles: string[] =
+    role === "all" ? ["primary", "secondary"] : [role];
+  const updates: Record<string, string> = {};
+
+  switch (role) {
+    case "all":
+      updates.primaryModel = finalModelName;
+      updates.secondaryModel = finalModelName;
+      break;
+    case "primary":
+      updates.primaryModel = finalModelName;
+      break;
+    case "secondary":
+      updates.secondaryModel = finalModelName;
+      break;
+    default:
+      updateOutput(
+        "log",
+        `Unknown role: ${role}. Use: p|primary, s|secondary, a|all`,
+      );
+      return;
+  }
+
+  // Single write for all updates
+  await UpdateSettings(updates);
+
+  updateOutput(
+    "log",
+    `✓ Set ${changedRoles.join(", ")} model to: ${displayName}`,
+  );
+};
+
+const modelSetCommands: Command = {
+  name: "model",
+  description: "Set active model(s) by role",
+  usage: "/model <model-name> <role>",
+  action: setModel,
+  subcommands: [
+    {
+      name: "all",
+      description: "Set model for all roles",
+      usage: "/model all <model-name>",
+    },
+    {
+      name: "primary",
+      description: "Set primary model",
+      usage: "/model primary <model-name>",
+    },
+    {
+      name: "secondary",
+      description: "Set secondary model",
+      usage: "/model secondary <model-name>",
+    },
+  ],
+};
+
+export default modelSetCommands;

package/src/commands/models/index.ts

@@ -0,0 +1,16 @@
+import type { Command } from "@/types/CommandDefinition";
+import useFraudeStore from "@/store/useFraudeStore";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const listModelsCommand: Command = {
+  name: "models",
+  description: "List available models",
+  usage: "/models [provider]",
+  action: async (args: string[]) => {
+    const provider = args[0]?.toLowerCase();
+    updateOutput("settings", provider ? `/models:${provider}` : "/models");
+  },
+};
+
+export default listModelsCommand;

package/src/commands/ollama/index.ts

@@ -0,0 +1,29 @@
+import type { Command } from "@/types/CommandDefinition";
+import useFraudeStore from "@/store/useFraudeStore";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const ollamaCommand: Command = {
+  name: "ollama",
+  description: "Manage Ollama models",
+  usage: "/ollama [subcommand]",
+  action: async (args: string[]) => {
+    if (args.length === 0 || args[0] === "list" || args[0] === "models") {
+      updateOutput("settings", "/models:ollama");
+      return;
+    }
+    // Future: handle other ollama subcommands like pull, rm, etc.
+  },
+  subcommands: [
+    {
+      name: "list",
+      description: "List Ollama models",
+      usage: "/ollama list",
+      action: async () => {
+        updateOutput("settings", "/models:ollama");
+      },
+    },
+  ],
+};
+
+export default ollamaCommand;

package/src/commands/openrouter/add_model.ts

@@ -0,0 +1,64 @@
+import type { Command } from "@/types/CommandDefinition";
+import { UpdateSettings } from "@/config/settings";
+import useFraudeStore from "@/store/useFraudeStore";
+import OpenRouterClient from "@/services/openrouter";
+import type { Model } from "@/types/Model";
+import useSettingsStore from "@/store/useSettingsStore";
+
+const { updateOutput } = useFraudeStore.getState();
+
+const addOpenRouterModel = async (args: string[]) => {
+  const model = args[0];
+  if (!model) {
+    updateOutput("error", "No model specified (OpenRouter)");
+    return;
+  }
+  const data: any = await OpenRouterClient.getModelData(model);
+  const modelData = data.data;
+
+  if (!modelData) {
+    throw new Error(`No data found for OpenRouter model ${model}`);
+  }
+
+  const endpoint = modelData.endpoints?.[0];
+
+  const newModel: Model = {
+    type: "openrouter",
+    name: modelData.id,
+    modified_at: new Date(modelData.created * 1000).toISOString(),
+    digest: modelData.id,
+    capabilities: endpoint?.supported_parameters || [],
+    usage: {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+    },
+    details: {
+      context_length: endpoint?.context_length,
+    },
+  };
+
+  const savedModels = useSettingsStore.getState().models || [];
+
+  // Check if model already exists, update if so, else add
+  const existingIndex = savedModels.findIndex(
+    (m) => m.name === newModel.name && m.type === "openrouter",
+  );
+
+  if (existingIndex >= 0) {
+    savedModels[existingIndex] = newModel;
+  } else {
+    savedModels.push(newModel);
+  }
+  await UpdateSettings({ models: savedModels });
+  updateOutput("log", "OpenRouter model added: " + model);
+};
+
+const addOpenRouterModelCommand: Command = {
+  name: "add",
+  description: "Add OpenRouter model",
+  usage: "/openrouter add <model>",
+  action: addOpenRouterModel,
+};
+
+export default addOpenRouterModelCommand;

package/src/commands/openrouter/auth.ts

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

package/src/commands/openrouter/index.ts

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