@oisheek_c/codeforge 1.0.1

package/packages/agent/thinking.js

@@ -0,0 +1,54 @@
+const DEFAULT_OPTIONS = Object.freeze({
+  enabled: false,
+  mode: "standard",
+  budget: "medium",
+});
+
+export function configureThinking({
+  plan,
+  route,
+}) {
+  if (!plan?.requiresThinking) {
+    return DEFAULT_OPTIONS;
+  }
+
+  let mode = "standard";
+  let budget = "medium";
+
+  switch (plan.intent) {
+    case "plan":
+      mode = "deep";
+      budget = "high";
+      break;
+
+    case "debug":
+      mode = "deep";
+      budget = "high";
+      break;
+
+    case "review":
+      mode = "deep";
+      budget = "high";
+      break;
+
+    case "refactor":
+      mode = "deep";
+      budget = "high";
+      break;
+
+    case "code":
+      mode = "balanced";
+      budget = "medium";
+      break;
+
+    default:
+      mode = "standard";
+      budget = "medium";
+  }
+
+  return {
+    enabled: Boolean(route?.thinking),
+    mode,
+    budget,
+  };
+}

package/packages/agent/toolCalls.js

@@ -0,0 +1,258 @@
+function createToolCallError(
+  code,
+  message,
+  details = null
+) {
+  const error = new Error(message);
+
+  error.code = code;
+  error.details = details;
+
+  return error;
+}
+
+function parseArguments(value) {
+  if (value == null || value === "") {
+    return {};
+  }
+
+  if (
+    typeof value === "object" &&
+    !Array.isArray(value)
+  ) {
+    return value;
+  }
+
+  if (typeof value !== "string") {
+    throw createToolCallError(
+      "invalid_tool_arguments",
+      "Tool call arguments must be a JSON object or JSON string."
+    );
+  }
+
+  let parsed;
+
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw createToolCallError(
+      "invalid_tool_arguments",
+      "Tool call arguments contain invalid JSON."
+    );
+  }
+
+  if (
+    parsed == null ||
+    typeof parsed !== "object" ||
+    Array.isArray(parsed)
+  ) {
+    throw createToolCallError(
+      "invalid_tool_arguments",
+      "Tool call arguments must resolve to an object."
+    );
+  }
+
+  return parsed;
+}
+
+export function normalizeToolCall(
+  toolCall
+) {
+  if (
+    !toolCall ||
+    typeof toolCall !== "object"
+  ) {
+    throw createToolCallError(
+      "invalid_tool_call",
+      "Tool call must be an object."
+    );
+  }
+
+  const id =
+    toolCall.id ?? null;
+
+  const type =
+    toolCall.type ?? "function";
+
+  const fn =
+    toolCall.function;
+
+  if (
+    !fn ||
+    typeof fn !== "object"
+  ) {
+    throw createToolCallError(
+      "invalid_tool_call",
+      "Tool call does not contain a function definition."
+    );
+  }
+
+  if (
+    typeof fn.name !== "string" ||
+    fn.name.trim().length === 0
+  ) {
+    throw createToolCallError(
+      "invalid_tool_name",
+      "Tool call does not contain a valid tool name."
+    );
+  }
+
+  return {
+    id,
+    type,
+    name: fn.name.trim(),
+    arguments:
+      parseArguments(
+        fn.arguments
+      ),
+  };
+}
+
+export function normalizeToolCalls(
+  toolCalls = []
+) {
+  if (toolCalls == null) {
+    return [];
+  }
+
+  if (!Array.isArray(toolCalls)) {
+    throw createToolCallError(
+      "invalid_tool_calls",
+      "Tool calls must be an array."
+    );
+  }
+
+  return toolCalls.map(
+    normalizeToolCall
+  );
+}
+
+export function resolveToolCalls(
+  toolCalls,
+  registry
+) {
+  const normalized =
+    normalizeToolCalls(toolCalls);
+
+  if (normalized.length === 0) {
+    return [];
+  }
+
+  if (
+    !registry ||
+    typeof registry.get !== "function"
+  ) {
+    throw createToolCallError(
+      "tool_registry_required",
+      "A tool registry is required to resolve tool calls."
+    );
+  }
+
+  return normalized.map(
+    (toolCall) => {
+      const tool =
+        registry.get(
+          toolCall.name
+        );
+
+      if (!tool) {
+  const availableTools =
+    typeof registry.describe === "function"
+      ? registry
+          .describe()
+          .map((item) => item?.name)
+          .filter(Boolean)
+      : [];
+
+  const availableToolText =
+    availableTools.length > 0
+      ? ` Available tools: ${availableTools.join(", ")}.`
+      : "";
+
+  throw createToolCallError(
+    "tool_not_found",
+    `Tool is not registered: ${toolCall.name}.${availableToolText} Use only registered tools.`,
+    {
+      tool:
+        toolCall.name,
+
+      availableTools,
+    }
+  );
+}
+
+      return {
+        ...toolCall,
+        tool,
+      };
+    }
+  );
+  
+}
+
+export function createToolCallFailure({
+  toolCall,
+  error,
+}) {
+  const id =
+  typeof toolCall?.id === "string" &&
+  toolCall.id.trim().length > 0
+    ? toolCall.id
+    : `invalid_tool_call_${Date.now()}_${Math.random()
+        .toString(36)
+        .slice(2, 10)}`;
+
+  const name =
+    typeof toolCall?.function?.name === "string"
+      ? toolCall.function.name.trim()
+      : null;
+
+  return {
+    id,
+    name,
+    arguments: null,
+
+    result: {
+      success: false,
+      tool: name,
+
+      output: null,
+
+      error: {
+        code:
+          error?.code ??
+          "invalid_tool_call",
+
+        message:
+          error?.message ??
+          "Invalid tool call.",
+
+        details:
+          error?.details ?? null,
+      },
+
+      metadata: {
+        source: "model",
+        sideEffect: "none",
+        approval: "never",
+
+        authorization: {
+          allowed: false,
+          code:
+            error?.code ??
+            "invalid_tool_call",
+          reason:
+            error?.message ??
+            "Invalid tool call.",
+          requiresApproval: false,
+        },
+      },
+
+      timing: {
+        startedAt: Date.now(),
+        completedAt: Date.now(),
+        durationMs: 0,
+      },
+    },
+  };
+}

package/packages/config/config.js

@@ -0,0 +1,391 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+import { defaultConfig } from "./defaults.js";
+
+const CONFIG_DIR = path.join(os.homedir(), ".codeforge");
+const CURRENT_CONFIG_VERSION = 2;
+
+const MODEL_ROLES = [
+  "fast",
+  "general",
+  "coding",
+  "heavyCoding",
+  "planner",
+  "subagent",
+  "vision",
+  "documentVision",
+  "embedding",
+  "reranker",
+  "fallback",
+  "emergency",
+];
+
+const SELECTOR_ROLES = [
+  "rag",
+  "model",
+];
+
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const SESSION_FILE = path.join(CONFIG_DIR, "session.json");
+
+const CACHE_DIR = path.join(CONFIG_DIR, "cache");
+const LOGS_DIR = path.join(CONFIG_DIR, "logs");
+const HISTORY_DIR = path.join(CONFIG_DIR, "history");
+
+function ensureConfigDirectory() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.mkdirSync(CACHE_DIR, { recursive: true });
+  fs.mkdirSync(LOGS_DIR, { recursive: true });
+  fs.mkdirSync(HISTORY_DIR, { recursive: true });
+}
+
+function ensureConfigFile() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    fs.writeFileSync(
+      CONFIG_FILE,
+      JSON.stringify(
+        {
+          ...defaultConfig,
+          configVersion: CURRENT_CONFIG_VERSION,
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+  }
+}
+
+function ensureSessionFile() {
+  if (!fs.existsSync(SESSION_FILE)) {
+    fs.writeFileSync(
+      SESSION_FILE,
+      JSON.stringify({}, null, 2),
+      "utf8"
+    );
+  }
+}
+
+export function validateConfig(config) {
+  if (
+    !config ||
+    typeof config !== "object" ||
+    Array.isArray(config)
+  ) {
+    throw new TypeError(
+      "Configuration must be an object."
+    );
+  }
+
+  if (
+    typeof config.provider !== "string" ||
+    config.provider.trim().length === 0
+  ) {
+    throw new TypeError(
+      "Configuration provider must be a non-empty string."
+    );
+  }
+
+  if (
+    !config.models ||
+    typeof config.models !== "object" ||
+    Array.isArray(config.models)
+  ) {
+    throw new TypeError(
+      "Configuration models must be an object."
+    );
+  }
+
+  for (const role of MODEL_ROLES) {
+    if (
+      typeof config.models[role] !== "string" ||
+      config.models[role].trim().length === 0
+    ) {
+      throw new TypeError(
+        `Configuration model "${role}" must be a non-empty string.`
+      );
+    }
+  }
+
+  if (
+    !config.selectors ||
+    typeof config.selectors !== "object" ||
+    Array.isArray(config.selectors)
+  ) {
+    throw new TypeError(
+      "Configuration selectors must be an object."
+    );
+  }
+
+  if (
+    typeof config.selectors.provider !== "string" ||
+    config.selectors.provider.trim().length === 0
+  ) {
+    throw new TypeError(
+      "Configuration selector provider must be a non-empty string."
+    );
+  }
+
+  for (const field of SELECTOR_ROLES) {
+    if (
+      typeof config.selectors[field] !== "string" ||
+      config.selectors[field].trim().length === 0
+    ) {
+      throw new TypeError(
+        `Configuration selector "${field}" must be a non-empty string.`
+      );
+    }
+  }
+
+  for (const field of [
+    "maxTokens",
+    "modelMaxTokens",
+  ]) {
+    if (
+      !Number.isFinite(config.selectors[field]) ||
+      config.selectors[field] <= 0
+    ) {
+      throw new TypeError(
+        `Configuration selector "${field}" must be a positive number.`
+      );
+    }
+  }
+
+  if (!Number.isFinite(config.temperature)) {
+    throw new TypeError(
+      "Configuration temperature must be a finite number."
+    );
+  }
+
+  if (
+    !Number.isFinite(config.maxTokens) ||
+    config.maxTokens <= 0
+  ) {
+    throw new TypeError(
+      "Configuration maxTokens must be a positive number."
+    );
+  }
+
+  return true;
+}
+
+/**
+ * Migrate an existing configuration without destroying
+ * explicit user customizations.
+ *
+ * Legacy values that exactly match the old defaults are
+ * replaced with the current defaults.
+ *
+ * Values that differ from the old defaults are preserved.
+ */
+export function migrateConfig(config) {
+  if (
+    !config ||
+    typeof config !== "object" ||
+    Array.isArray(config)
+  ) {
+    return {
+      config: {
+        ...defaultConfig,
+        configVersion: CURRENT_CONFIG_VERSION,
+      },
+      migrated: true,
+    };
+  }
+
+  const version = Number(config.configVersion ?? 0);
+
+  if (version >= CURRENT_CONFIG_VERSION) {
+    return {
+      config,
+      migrated: false,
+    };
+  }
+
+  const migratedConfig = {
+    ...defaultConfig,
+    ...config,
+
+    configVersion: CURRENT_CONFIG_VERSION,
+
+    models: {
+      ...defaultConfig.models,
+      ...(config.models ?? {}),
+    },
+
+    selectors: {
+      ...defaultConfig.selectors,
+      ...(config.selectors ?? {}),
+    },
+  };
+
+  return {
+    config: migratedConfig,
+    migrated: true,
+  };
+}
+
+function ensureConfig() {
+  ensureConfigDirectory();
+  ensureConfigFile();
+}
+
+function getEnvOverride(name, fallback) {
+  const value = process.env[name];
+
+  return typeof value === "string" && value.trim().length > 0
+    ? value
+    : fallback;
+}
+
+export function loadConfig() {
+  ensureConfig();
+
+  let config = {};
+
+  try {
+    config = JSON.parse(
+      fs.readFileSync(CONFIG_FILE, "utf8")
+    );
+  } catch {
+    config = {};
+  }
+
+  const migration = migrateConfig(config);
+  config = migration.config;
+
+  if (migration.migrated) {
+    saveConfig(config);
+  }
+
+  const configuredModels = {
+    ...defaultConfig.models,
+    ...(config.models ?? {}),
+  };
+
+  const configuredSelectors = {
+    ...defaultConfig.selectors,
+    ...(config.selectors ?? {}),
+  };
+
+const models = {
+  fast: getEnvOverride(
+    "CODEFORGE_MODEL_FAST",
+    configuredModels.fast
+  ),
+
+  general: getEnvOverride(
+    "CODEFORGE_MODEL_GENERAL",
+    configuredModels.general
+  ),
+
+  coding: getEnvOverride(
+    "CODEFORGE_MODEL_CODING",
+    configuredModels.coding
+  ),
+
+  heavyCoding: getEnvOverride(
+    "CODEFORGE_MODEL_HEAVY_CODING",
+    configuredModels.heavyCoding
+  ),
+
+  planner: getEnvOverride(
+    "CODEFORGE_MODEL_PLANNER",
+    configuredModels.planner
+  ),
+
+  subagent: getEnvOverride(
+    "CODEFORGE_MODEL_SUBAGENT",
+    configuredModels.subagent
+  ),
+
+  vision: getEnvOverride(
+    "CODEFORGE_MODEL_VISION",
+    configuredModels.vision
+  ),
+
+  documentVision: getEnvOverride(
+    "CODEFORGE_MODEL_DOCUMENT_VISION",
+    configuredModels.documentVision
+  ),
+
+  embedding: getEnvOverride(
+    "CODEFORGE_MODEL_EMBEDDING",
+    configuredModels.embedding
+  ),
+
+  reranker: getEnvOverride(
+    "CODEFORGE_MODEL_RERANKER",
+    configuredModels.reranker
+  ),
+
+  fallback: getEnvOverride(
+    "CODEFORGE_MODEL_FALLBACK",
+    configuredModels.fallback
+  ),
+
+  emergency: getEnvOverride(
+    "CODEFORGE_MODEL_EMERGENCY",
+    configuredModels.emergency
+  ),
+};
+ const selectors = {
+  provider: getEnvOverride(
+    "CODEFORGE_SELECTOR_PROVIDER",
+    configuredSelectors.provider
+  ),
+
+  rag: getEnvOverride(
+    "CODEFORGE_SELECTOR_RAG",
+    configuredSelectors.rag
+  ),
+
+  model: getEnvOverride(
+    "CODEFORGE_SELECTOR_MODEL",
+    configuredSelectors.model
+  ),
+
+  maxTokens: configuredSelectors.maxTokens,
+
+  modelMaxTokens:
+    configuredSelectors.modelMaxTokens,
+};
+
+  return {
+  ...defaultConfig,
+  ...config,
+  configVersion: CURRENT_CONFIG_VERSION,
+  apiKey: getEnvOverride(
+    "OPENROUTER_API_KEY",
+    config.apiKey ?? ""
+  ),
+  models,
+  selectors,
+};
+}
+
+export function saveConfig(config) {
+  ensureConfigDirectory();
+
+  fs.writeFileSync(
+    CONFIG_FILE,
+    JSON.stringify(config, null, 2),
+    "utf8"
+  );
+}
+
+export {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  SESSION_FILE,
+  CACHE_DIR,
+  LOGS_DIR,
+  HISTORY_DIR,
+  MODEL_ROLES,
+  SELECTOR_ROLES,
+  ensureConfigDirectory,
+  ensureConfigFile,
+  ensureSessionFile,
+};