noiton 1.0.0 → 2.0.0

package/src/lib/agents/cline.js

@@ -0,0 +1,128 @@
+/**
+ * Cline Agent Adapter
+ *
+ * Config: VS Code settings.json with cline config block.
+ * Format (under `cline` key):
+ *   "cline.provider": "openai",
+ *   "cline.openAiBaseUrl": "<BASE_URL>",
+ *   "cline.openAiApiKey": "<key>",
+ *   "cline.openAiModelId": "<model>"
+ *
+ * VS Code stores multiple providers via cline.provider entries.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import JSON5 from "json5";
+import { BASE_URL, PROVIDER_ID } from "../../constants.js";
+
+const HOME = homedir();
+const XDG = process.env.XDG_CONFIG_HOME || join(HOME, ".config");
+const CONFIG_PATH = join(XDG, "Code", "User", "settings.json");
+
+function readConfig() {
+  if (!existsSync(CONFIG_PATH)) return { config: {}, path: CONFIG_PATH };
+  try {
+    // VS Code settings support JSON with comments (JSONC)
+    const raw = readFileSync(CONFIG_PATH, "utf8");
+    const cleaned = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    return { config: JSON5.parse(cleaned), path: CONFIG_PATH };
+  } catch {
+    return { config: {}, path: CONFIG_PATH };
+  }
+}
+
+function writeConfig(config) {
+  if (!existsSync(dirname(CONFIG_PATH))) {
+    mkdirSync(dirname(dirname(CONFIG_PATH)), { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+// ============= ADAPTER INTERFACE =============
+
+export const clineAgent = {
+  id: "cline",
+  name: "Cline",
+  supportsMultipleModels: true,
+
+  detect() {
+    return existsSync(CONFIG_PATH);
+  },
+
+  isConfigured() {
+    const { config } = readConfig();
+    const result = Boolean(
+      config?.["cline.openAiBaseUrl"] === BASE_URL ||
+      config?.["cline.apiProvider"] === "openai" && config?.["cline.openAiApiKey"]
+    );
+    return result;
+  },
+
+  getStatus() {
+    const { config, path } = readConfig();
+    const baseUrl = config?.["cline.openAiBaseUrl"];
+    const apiKey = config?.["cline.openAiApiKey"];
+    const modelId = config?.["cline.openAiModelId"];
+    const configured = Boolean(baseUrl === BASE_URL || (apiKey && baseUrl));
+
+    const models = modelId ? [modelId] : [];
+
+    return {
+      configured,
+      path,
+      models,
+      apiKey: apiKey ? `${apiKey.slice(0, 6)}...${apiKey.slice(-4)}` : null,
+    };
+  },
+
+  configure({ apiKey, models, primaryModel }) {
+    const { config } = readConfig();
+    config["cline.apiProvider"] = "openai";
+    config["cline.openAiBaseUrl"] = `${BASE_URL}/v1`;
+    config["cline.openAiApiKey"] = apiKey;
+    config["cline.openAiModelId"] = primaryModel || models[0]?.id;
+    // Save list of available models as a JSON array string
+    config["cline.noitonModels"] = JSON.stringify(models.map((m) => m.id));
+    writeConfig(config);
+    return { path: CONFIG_PATH, modelsCount: 1 };
+  },
+
+  changeKey(apiKey) {
+    const { config } = readConfig();
+    if (!config?.["cline.openAiApiKey"]) {
+      throw new Error("NOITON não está configurado no Cline");
+    }
+    config["cline.openAiApiKey"] = apiKey;
+    writeConfig(config);
+    return { path: CONFIG_PATH };
+  },
+
+  refresh(models) {
+    const { config } = readConfig();
+    if (!config?.["cline.openAiBaseUrl"]) {
+      throw new Error("NOITON não está configurado no Cline");
+    }
+    config["cline.openAiModelId"] = models[0]?.id || config["cline.openAiModelId"];
+    config["cline.noitonModels"] = JSON.stringify(models.map((m) => m.id));
+    writeConfig(config);
+    return { path: CONFIG_PATH, modelsCount: 1 };
+  },
+
+  remove() {
+    const { config } = readConfig();
+    let removed = false;
+    if (config?.["cline.openAiBaseUrl"] === BASE_URL ||
+        config?.["cline.openAiApiKey"]) {
+      delete config["cline.apiProvider"];
+      delete config["cline.openAiBaseUrl"];
+      delete config["cline.openAiApiKey"];
+      delete config["cline.openAiModelId"];
+      delete config["cline.noitonModels"];
+      removed = true;
+    }
+    if (removed) writeConfig(config);
+    return { path: CONFIG_PATH, removed };
+  },
+};

package/src/lib/agents/hermes.js

@@ -0,0 +1,156 @@
+/**
+ * Hermes Agent Adapter
+ *
+ * Config: ~/.hermes/config.yaml (YAML) + ~/.hermes/.env (env vars)
+ * Format:
+ *   model:
+ *     default: <model-id>
+ *     provider: custom
+ *     base_url: <BASE_URL>
+ *     api_key: ${NOITON_API_KEY}
+ *   .env: NOITON_API_KEY=<key>
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import YAML from "yaml";
+import { BASE_URL } from "../../constants.js";
+
+const HOME = homedir();
+const CONFIG_PATH = join(HOME, ".hermes", "config.yaml");
+const ENV_PATH = join(HOME, ".hermes", ".env");
+const ENV_KEY = "NOITON_API_KEY";
+
+function readYaml() {
+  if (!existsSync(CONFIG_PATH)) return { config: {}, path: CONFIG_PATH };
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf8");
+    return { config: YAML.parse(raw) || {}, path: CONFIG_PATH };
+  } catch {
+    return { config: {}, path: CONFIG_PATH };
+  }
+}
+
+function writeYaml(config) {
+  if (!existsSync(dirname(CONFIG_PATH))) {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, YAML.stringify(config, { indent: 2 }), "utf8");
+}
+
+function readEnv() {
+  if (!existsSync(ENV_PATH)) return {};
+  const raw = readFileSync(ENV_PATH, "utf8");
+  const env = {};
+  for (const line of raw.split("\n")) {
+    const m = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+    if (m) env[m[1]] = m[2];
+  }
+  return env;
+}
+
+function writeEnv(env) {
+  if (!existsSync(dirname(ENV_PATH))) {
+    mkdirSync(dirname(ENV_PATH), { recursive: true });
+  }
+  const lines = Object.entries(env).map(([k, v]) => `${k}=${v}`);
+  writeFileSync(ENV_PATH, lines.join("\n") + "\n", "utf8");
+}
+
+function setEnvKey(key, value) {
+  const env = readEnv();
+  env[key] = value;
+  writeEnv(env);
+}
+
+function getEnvKey(key) {
+  return readEnv()[key] || null;
+}
+
+// ============= ADAPTER INTERFACE =============
+
+export const hermesAgent = {
+  id: "hermes",
+  name: "Hermes",
+  supportsMultipleModels: false,
+
+  detect() {
+    return existsSync(CONFIG_PATH) || existsSync(ENV_PATH);
+  },
+
+  isConfigured() {
+    const { config } = readYaml();
+    return Boolean(config?.model?.base_url === BASE_URL || getEnvKey(ENV_KEY));
+  },
+
+  getStatus() {
+    const { config, path } = readYaml();
+    const apiKey = getEnvKey(ENV_KEY);
+    const configured = config?.model?.base_url === BASE_URL || Boolean(apiKey);
+    const models = config?.model?.default ? [config.model.default] : [];
+    return { configured, path, models, apiKey, envPath: ENV_PATH };
+  },
+
+  configure({ apiKey, models, primaryModel }) {
+    const { config } = readYaml();
+    config.model = config.model || {};
+    config.model.default = primaryModel || models[0]?.id || "glm-5.2";
+    config.model.provider = "custom";
+    config.model.base_url = BASE_URL;
+    config.model.api_key = `\${${ENV_KEY}}`;
+    if (models[0]?.context_window) {
+      config.model.context_length = models[0].context_window;
+    }
+    writeYaml(config);
+    setEnvKey(ENV_KEY, apiKey);
+    return { path: CONFIG_PATH, envPath: ENV_PATH, modelsCount: 1 };
+  },
+
+  changeKey(apiKey) {
+    if (!this.isConfigured()) {
+      throw new Error("NOITON não está configurado no Hermes");
+    }
+    setEnvKey(ENV_KEY, apiKey);
+    return { path: ENV_PATH };
+  },
+
+  refresh(models) {
+    const { config } = readYaml();
+    if (!config?.model?.base_url) {
+      throw new Error("NOITON não está configurado no Hermes");
+    }
+    // Hermes uses a single default model - keep current or update to first
+    if (models.length > 0 && !config.model.default) {
+      config.model.default = models[0].id;
+    }
+    if (models[0]?.context_window) {
+      config.model.context_length = models[0].context_window;
+    }
+    writeYaml(config);
+    return { path: CONFIG_PATH, modelsCount: models.length };
+  },
+
+  remove() {
+    const { config } = readYaml();
+    let removed = false;
+    if (config?.model?.base_url === BASE_URL) {
+      delete config.model.base_url;
+      delete config.model.api_key;
+      delete config.model.provider;
+      delete config.model.context_length;
+      delete config.model.default;
+      if (Object.keys(config.model).length === 0) delete config.model;
+      writeYaml(config);
+      removed = true;
+    }
+    // Remove env key
+    const env = readEnv();
+    if (env[ENV_KEY]) {
+      delete env[ENV_KEY];
+      writeEnv(env);
+      removed = true;
+    }
+    return { path: CONFIG_PATH, envPath: ENV_PATH, removed };
+  },
+};

package/src/lib/agents/index.js

@@ -0,0 +1,82 @@
+/**
+ * NOITON Agent Registry
+ *
+ * Central registry of all agent adapters. Each adapter implements:
+ *   { id, name, supportsMultipleModels, detect, isConfigured, getStatus,
+ *     configure, changeKey, refresh, remove }
+ */
+
+import { opencodeAgent } from "./opencode.js";
+import { hermesAgent } from "./hermes.js";
+import { openclawAgent } from "./openclaw.js";
+import { clineAgent } from "./cline.js";
+import { aiderAgent } from "./aider.js";
+import { kiloAgent } from "./kilo.js";
+import { kimiAgent } from "./kimi.js";
+
+export const REGISTRY = [
+  opencodeAgent,
+  hermesAgent,
+  openclawAgent,
+  clineAgent,
+  aiderAgent,
+  kiloAgent,
+  kimiAgent,
+];
+
+/**
+ * Get an agent adapter by ID.
+ * @param {string} id
+ * @returns {object|null}
+ */
+export function getAgent(id) {
+  return REGISTRY.find((a) => a.id === id) || null;
+}
+
+/**
+ * Get all agents that are detected as installed.
+ * @returns {Array}
+ */
+export function getDetectedAgents() {
+  return REGISTRY.filter((a) => a.detect());
+}
+
+/**
+ * Get all agents that have NOITON configured.
+ * @returns {Array}
+ */
+export function getConfiguredAgents() {
+  return REGISTRY.filter((a) => {
+    try {
+      return a.isConfigured();
+    } catch {
+      return false;
+    }
+  });
+}
+
+/**
+ * Get status of all detected agents.
+ * @returns {Array}
+ */
+export function getAllStatuses() {
+  return REGISTRY.map((a) => {
+    try {
+      const detected = a.detect();
+      const status = detected ? a.getStatus() : null;
+      return {
+        id: a.id,
+        name: a.name,
+        detected,
+        ...status,
+      };
+    } catch (err) {
+      return {
+        id: a.id,
+        name: a.name,
+        detected: false,
+        error: err.message,
+      };
+    }
+  });
+}

package/src/lib/agents/kilo.js

@@ -0,0 +1,140 @@
+/**
+ * Kilo Code Agent Adapter
+ *
+ * Config: ~/.config/kilo/kilo.jsonc (JSONC)
+ * Format (under `provider.openai-compatible`):
+ *   model: openai-compatible/<model-id>
+ *   provider.openai-compatible.options.apiKey
+ *   provider.openai-compatible.options.baseURL
+ *   provider.openai-compatible.models.<id>.limit.context/output
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import JSON5 from "json5";
+import { BASE_URL } from "../../constants.js";
+
+const HOME = homedir();
+const XDG = process.env.XDG_CONFIG_HOME || join(HOME, ".config");
+const CONFIG_PATH = join(XDG, "kilo", "kilo.jsonc");
+const PROVIDER_ID = "openai-compatible";
+
+function readConfig() {
+  if (!existsSync(CONFIG_PATH)) return { config: {}, path: CONFIG_PATH };
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf8");
+    // Strip comments (JSONC)
+    const cleaned = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    return { config: JSON5.parse(cleaned), path: CONFIG_PATH };
+  } catch {
+    return { config: {}, path: CONFIG_PATH };
+  }
+}
+
+function writeConfig(config) {
+  if (!existsSync(dirname(CONFIG_PATH))) {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+function buildModels(models) {
+  const obj = {};
+  for (const m of models) {
+    if (!m.id) continue;
+    obj[m.id] = {
+      name: prettifyName(m.id),
+      tool_call: true,
+      limit: { context: m.context_window || 32768, output: 4096 },
+    };
+  }
+  return obj;
+}
+
+function prettifyName(id) {
+  return id
+    .replace(/[@/]/g, " ")
+    .split(/[-_]/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(" ");
+}
+
+// ============= ADAPTER INTERFACE =============
+
+export const kiloAgent = {
+  id: "kilo",
+  name: "Kilo Code",
+  supportsMultipleModels: true,
+
+  detect() {
+    return existsSync(CONFIG_PATH);
+  },
+
+  isConfigured() {
+    const { config } = readConfig();
+    return Boolean(config?.provider?.[PROVIDER_ID]?.options?.baseURL === BASE_URL);
+  },
+
+  getStatus() {
+    const { config, path } = readConfig();
+    const provider = config?.provider?.[PROVIDER_ID];
+    if (!provider) return { configured: false, path, models: [], apiKey: null };
+    const apiKey = provider.options?.apiKey;
+    const models = provider.models ? Object.keys(provider.models) : [];
+    return {
+      configured: provider.options?.baseURL === BASE_URL,
+      path,
+      models,
+      apiKey: apiKey ? (apiKey.startsWith("{env:") ? "(env var)" : `${apiKey.slice(0, 6)}...${apiKey.slice(-4)}`) : null,
+    };
+  },
+
+  configure({ apiKey, models, primaryModel }) {
+    const { config } = readConfig();
+    config.model = `${PROVIDER_ID}/${primaryModel || models[0]?.id}`;
+    config.provider = config.provider || {};
+    config.provider[PROVIDER_ID] = {
+      options: {
+        apiKey,
+        baseURL: `${BASE_URL}/v1`,
+      },
+      models: buildModels(models),
+    };
+    writeConfig(config);
+    return { path: CONFIG_PATH, modelsCount: models.length };
+  },
+
+  changeKey(apiKey) {
+    const { config } = readConfig();
+    if (!config?.provider?.[PROVIDER_ID]) {
+      throw new Error("NOITON não está configurado no Kilo Code");
+    }
+    config.provider[PROVIDER_ID].options.apiKey = apiKey;
+    writeConfig(config);
+    return { path: CONFIG_PATH };
+  },
+
+  refresh(models) {
+    const { config } = readConfig();
+    if (!config?.provider?.[PROVIDER_ID]) {
+      throw new Error("NOITON não está configurado no Kilo Code");
+    }
+    config.provider[PROVIDER_ID].models = buildModels(models);
+    writeConfig(config);
+    return { path: CONFIG_PATH, modelsCount: models.length };
+  },
+
+  remove() {
+    const { config } = readConfig();
+    let removed = false;
+    if (config?.provider?.[PROVIDER_ID]) {
+      delete config.provider[PROVIDER_ID];
+      delete config.model;
+      removed = true;
+      writeConfig(config);
+    }
+    return { path: CONFIG_PATH, removed };
+  },
+};

package/src/lib/agents/kimi.js

@@ -0,0 +1,149 @@
+/**
+ * Kimi Code Agent Adapter
+ *
+ * Config: ~/.kimi-code/config.toml (TOML)
+ * Format:
+ *   [providers.noiton]
+ *   type = "openai"
+ *   base_url = "<BASE_URL>/v1"
+ *   api_key = "<key>"
+ *
+ *   [models."<id>"]
+ *   provider = "noiton"
+ *   model = "<id>"
+ *   max_context_size = <ctx>
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import * as TOML from "@iarna/toml";
+import { BASE_URL, PROVIDER_ID } from "../../constants.js";
+
+const HOME = homedir();
+const CONFIG_PATH = join(HOME, ".kimi-code", "config.toml");
+
+function readConfig() {
+  if (!existsSync(CONFIG_PATH)) return { config: {}, path: CONFIG_PATH };
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf8");
+    return { config: TOML.parse(raw), path: CONFIG_PATH };
+  } catch {
+    return { config: {}, path: CONFIG_PATH };
+  }
+}
+
+function writeConfig(config) {
+  if (!existsSync(dirname(CONFIG_PATH))) {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, TOML.stringify(config), "utf8");
+}
+
+// ============= ADAPTER INTERFACE =============
+
+export const kimiAgent = {
+  id: "kimi",
+  name: "Kimi Code",
+  supportsMultipleModels: false,
+
+  detect() {
+    return existsSync(CONFIG_PATH);
+  },
+
+  isConfigured() {
+    const { config } = readConfig();
+    return Boolean(config?.providers?.[PROVIDER_ID]);
+  },
+
+  getStatus() {
+    const { config, path } = readConfig();
+    const provider = config?.providers?.[PROVIDER_ID];
+    if (!provider) return { configured: false, path, models: [], apiKey: null };
+    const apiKey = provider.api_key;
+    const models = config.models
+      ? Object.entries(config.models)
+          .filter(([, v]) => v.provider === PROVIDER_ID)
+          .map(([k]) => k)
+      : [];
+    return {
+      configured: true,
+      path,
+      models,
+      apiKey: apiKey ? `${apiKey.slice(0, 6)}...${apiKey.slice(-4)}` : null,
+    };
+  },
+
+  configure({ apiKey, models, primaryModel }) {
+    const { config } = readConfig();
+    config.providers = config.providers || {};
+    config.providers[PROVIDER_ID] = {
+      type: "openai",
+      base_url: `${BASE_URL}/v1`,
+      api_key: apiKey,
+    };
+
+    config.models = config.models || {};
+    const modelId = primaryModel || models[0]?.id || "glm-5.2";
+    config.models[modelId] = {
+      provider: PROVIDER_ID,
+      model: modelId,
+      max_context_size: models[0]?.context_window || 32768,
+    };
+
+    writeConfig(config);
+    return { path: CONFIG_PATH, modelsCount: 1 };
+  },
+
+  changeKey(apiKey) {
+    const { config } = readConfig();
+    if (!config?.providers?.[PROVIDER_ID]) {
+      throw new Error("NOITON não está configurado no Kimi Code");
+    }
+    config.providers[PROVIDER_ID].api_key = apiKey;
+    writeConfig(config);
+    return { path: CONFIG_PATH };
+  },
+
+  refresh(models) {
+    const { config } = readConfig();
+    if (!config?.providers?.[PROVIDER_ID]) {
+      throw new Error("NOITON não está configurado no Kimi Code");
+    }
+    // Update context size if model exists
+    const modelId = Object.keys(config.models || {}).find(
+      (k) => config.models[k]?.provider === PROVIDER_ID
+    );
+    if (modelId && models[0]?.context_window) {
+      config.models[modelId].max_context_size = models[0].context_window;
+    }
+    writeConfig(config);
+    return { path: CONFIG_PATH, modelsCount: 1 };
+  },
+
+  remove() {
+    const { config } = readConfig();
+    let removed = false;
+    if (config?.providers?.[PROVIDER_ID]) {
+      delete config.providers[PROVIDER_ID];
+      removed = true;
+    }
+    if (config?.models) {
+      for (const [k, v] of Object.entries(config.models)) {
+        if (v.provider === PROVIDER_ID) {
+          delete config.models[k];
+          removed = true;
+        }
+      }
+    }
+    // Clean up empty top-level tables
+    if (config.providers && Object.keys(config.providers).length === 0) {
+      delete config.providers;
+    }
+    if (config.models && Object.keys(config.models).length === 0) {
+      delete config.models;
+    }
+    if (removed) writeConfig(config);
+    return { path: CONFIG_PATH, removed };
+  },
+};