fraude-code 0.1.0

package/src/types/Model.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+
+export const ModelSchema = z.object({
+  type: z.string().default("ollama"),
+  name: z.string(),
+  modified_at: z.string().optional().default(new Date().toISOString()),
+  size: z.number().optional(),
+  digest: z.string().optional().default(""),
+  capabilities: z.array(z.string()).optional(),
+  usage: z
+    .object({
+      promptTokens: z.number().default(0),
+      completionTokens: z.number().default(0),
+      totalTokens: z.number().default(0),
+    })
+    .default({
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+    }),
+  details: z
+    .object({
+      format: z.string().optional(),
+      family: z.string().optional(),
+      families: z.array(z.string()).optional(),
+      parameter_size: z.string().optional(),
+      quantization_level: z.string().optional(),
+      context_length: z.number().optional(),
+    })
+    .catchall(z.any())
+    .optional()
+    .default({}),
+});
+
+export type Model = z.infer<typeof ModelSchema>;
+
+/**
+ * Creates a display identifier for a model that includes the provider
+ * Format: "modelName (provider)"
+ * Example: "openai/gpt-oss-120b (openrouter)"
+ */
+export function getModelDisplayId(model: Model): string {
+  return `${model.name} (${model.type})`;
+}
+
+/**
+ * Creates a display identifier from name and type
+ */
+export function createModelDisplayId(name: string, type: string): string {
+  return `${name} (${type})`;
+}
+
+/**
+ * Parses a display identifier back to name and type
+ * Returns null if the format is invalid
+ */
+export function parseModelDisplayId(
+  displayId: string,
+): { name: string; type: string } | null {
+  // Match pattern: "name (provider)"
+  const match = displayId.match(/^(.+)\s+\((\w+)\)$/);
+  if (!match || !match[1] || !match[2]) {
+    return null;
+  }
+
+  const name = match[1];
+  const type = match[2];
+
+  return { name, type };
+}
+
+/**
+ * Generates a unique ID for storing model references
+ * Format: "name|type"
+ */
+export function getModelUniqueId(model: Model): string {
+  return `${model.name}|${model.type}`;
+}
+
+/**
+ * Parses a unique ID back to name and type
+ */
+export function parseModelUniqueId(
+  uniqueId: string,
+): { name: string; type: string } | null {
+  const parts = uniqueId.split("|");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    return null;
+  }
+
+  const [name, type] = parts;
+
+  return { name, type };
+}

package/src/types/OutputItem.ts

@@ -0,0 +1,24 @@
+export type OutputItemType =
+  | "log"
+  | "markdown"
+  | "diff"
+  | "confirmation"
+  | "command"
+  | "done"
+  | "settings"
+  | "comment"
+  | "error"
+  | "reasoning"
+  | "interrupted"
+  | "toolCall"
+  | "agentText"
+  | "modelSelect"
+  | "knowledge"
+  | "interactive-server";
+
+export interface OutputItem {
+  id: string;
+  type: OutputItemType;
+  content: string;
+  duration?: number;
+}

package/src/types/PluginContext.ts

@@ -0,0 +1,55 @@
+import { BunApiRouter } from "@/utils/router";
+import type { Command } from "./CommandDefinition";
+import Agent from "@/agent/agent";
+
+export interface PluginContext {
+  /**
+   * Shared Router instance for registering endpoints
+   */
+  router: BunApiRouter;
+
+  /**
+   * Application logger
+   */
+  log: (...args: any[]) => void;
+
+  /**
+   * Router class for creating API endpoints
+   */
+  Router: typeof BunApiRouter;
+
+  /**
+   * The Agent class definition (constructor)
+   */
+  Agent: typeof Agent;
+
+  /**
+   * Settings management
+   */
+  settings: {
+    get: (key: string) => any;
+    getAll: () => any;
+    update: (updates: any) => Promise<void>;
+  };
+
+  /**
+   * UI / Store interaction
+   */
+  ui: {
+    updateOutput: (
+      type: "command" | "markdown" | "log" | "error",
+      content: string,
+    ) => void;
+  };
+
+  /**
+   * Global utilities (optional, e.g. if we want to expose 3rd party libs)
+   */
+  utils: {
+    // Add common utilities here if needed
+  };
+}
+
+export type PluginInit = (
+  context: PluginContext,
+) => Promise<Command | Command[]> | Command | Command[];

package/src/types/TokenUsage.ts

@@ -0,0 +1,5 @@
+export interface TokenUsage {
+  totalTokens: number;
+  promptTokens: number;
+  completionTokens: number;
+}

package/src/types/assets.d.ts

@@ -0,0 +1,4 @@
+declare module "*.txt" {
+  const content: string;
+  export default content;
+}