noiton 1.0.0 → 2.0.0

package/src/lib/agents/openclaw.js

@@ -0,0 +1,155 @@
+/**
+ * OpenClaw Agent Adapter
+ *
+ * Config: ~/.openclaw/openclaw.json (JSON5)
+ * Format:
+ *   models.providers.noiton = {
+ *     baseUrl, apiKey, api: "openai-completions", models: [...]
+ *   }
+ */
+
+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, PROVIDER_NAME } from "../../constants.js";
+
+const HOME = homedir();
+const CONFIG_PATH = join(HOME, ".openclaw", "openclaw.json");
+
+function readConfig() {
+  if (!existsSync(CONFIG_PATH)) return { config: {}, path: CONFIG_PATH };
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf8");
+    return { config: JSON5.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 });
+  }
+  // Write as standard JSON (OpenClaw accepts JSON5 which is a superset)
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+// ============= ADAPTER INTERFACE =============
+
+export const openclawAgent = {
+  id: "openclaw",
+  name: "OpenClaw",
+  supportsMultipleModels: true,
+
+  detect() {
+    return existsSync(CONFIG_PATH);
+  },
+
+  isConfigured() {
+    const { config } = readConfig();
+    return Boolean(config?.models?.providers?.[PROVIDER_ID]);
+  },
+
+  getStatus() {
+    const { config, path } = readConfig();
+    const provider = config?.models?.providers?.[PROVIDER_ID];
+    if (!provider) return { configured: false, path, models: [], apiKey: null };
+    const models = (provider.models || []).map((m) => m.id);
+    return {
+      configured: true,
+      path,
+      models,
+      apiKey: provider.apiKey,
+    };
+  },
+
+  configure({ apiKey, models, primaryModel }) {
+    const { config } = readConfig();
+    config.models = config.models || {};
+    config.models.mode = config.models.mode || "merge";
+    config.models.providers = config.models.providers || {};
+
+    config.models.providers[PROVIDER_ID] = {
+      baseUrl: `${BASE_URL}/v1`,
+      apiKey: `\${NOITON_API_KEY}`,
+      api: "openai-completions",
+      models: models.map((m) => ({
+        id: m.id,
+        name: prettifyName(m.id),
+        reasoning: false,
+        input: ["text"],
+        contextWindow: m.context_window || 32768,
+        maxTokens: 4096,
+      })),
+    };
+
+    // Set env for apiKey substitution
+    config.env = config.env || {};
+    config.env.NOITON_API_KEY = apiKey;
+
+    // Set default model if missing
+    if (!config.agents) config.agents = {};
+    if (!config.agents.defaults) config.agents.defaults = {};
+    if (!config.agents.defaults.model) {
+      config.agents.defaults.model = {
+        primary: `${PROVIDER_ID}/${primaryModel || models[0]?.id}`,
+      };
+    }
+
+    writeConfig(config);
+    return { path: CONFIG_PATH, modelsCount: models.length };
+  },
+
+  changeKey(apiKey) {
+    const { config } = readConfig();
+    if (!config?.models?.providers?.[PROVIDER_ID]) {
+      throw new Error("NOITON não está configurado no OpenClaw");
+    }
+    config.env = config.env || {};
+    config.env.NOITON_API_KEY = apiKey;
+    writeConfig(config);
+    return { path: CONFIG_PATH };
+  },
+
+  refresh(models) {
+    const { config } = readConfig();
+    if (!config?.models?.providers?.[PROVIDER_ID]) {
+      throw new Error("NOITON não está configurado no OpenClaw");
+    }
+    config.models.providers[PROVIDER_ID].models = models.map((m) => ({
+      id: m.id,
+      name: prettifyName(m.id),
+      reasoning: false,
+      input: ["text"],
+      contextWindow: m.context_window || 32768,
+      maxTokens: 4096,
+    }));
+    writeConfig(config);
+    return { path: CONFIG_PATH, modelsCount: models.length };
+  },
+
+  remove() {
+    const { config } = readConfig();
+    let removed = false;
+    if (config?.models?.providers?.[PROVIDER_ID]) {
+      delete config.models.providers[PROVIDER_ID];
+      removed = true;
+    }
+    if (config?.env?.NOITON_API_KEY) {
+      delete config.env.NOITON_API_KEY;
+      removed = true;
+    }
+    if (removed) writeConfig(config);
+    return { path: CONFIG_PATH, removed };
+  },
+};
+
+function prettifyName(id) {
+  return id
+    .replace(/[@/]/g, " ")
+    .split(/[-_]/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(" ");
+}

package/src/lib/agents/opencode.js

@@ -0,0 +1,177 @@
+/**
+ * OpenCode Agent Adapter
+ *
+ * Config: ~/.config/opencode/opencode.json (JSON)
+ * Format: provider.noiton = { npm, name, options: { baseURL, apiKey }, models }
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import {
+  PROVIDER_ID,
+  PROVIDER_NAME,
+  BASE_URL,
+  NPM_PACKAGE,
+} from "../../constants.js";
+
+const HOME = homedir();
+const XDG = process.env.XDG_CONFIG_HOME || join(HOME, ".config");
+
+/** @returns {string} config path */
+export function getConfigPath() {
+  if (process.env.OPENCODE_CONFIG) return process.env.OPENCODE_CONFIG;
+  return join(XDG, "opencode", "opencode.json");
+}
+
+/** @returns {{config: object, path: string}} */
+export function readConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path)) return { config: {}, path };
+  try {
+    return { config: JSON.parse(readFileSync(path, "utf8")), path };
+  } catch {
+    return { config: {}, path };
+  }
+}
+
+/** @param {object} config @param {string} [path] */
+export function writeConfig(config, path) {
+  const p = path || getConfigPath();
+  if (!existsSync(dirname(p))) mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+/** @param {object} config */
+export function hasProvider(config) {
+  return Boolean(config?.provider?.[PROVIDER_ID]);
+}
+
+/** @param {object} config */
+export function getProvider(config) {
+  return config?.provider?.[PROVIDER_ID] ?? null;
+}
+
+/** @param {Array} models @param {object} [defaults] */
+export function buildModels(models, defaults = {}) {
+  const ctx = defaults.context || 32768;
+  const out = defaults.output || 4096;
+  const result = {};
+  for (const m of models) {
+    if (!m.id) continue;
+    result[m.id] = {
+      name: prettifyName(m.id),
+      limit: { context: m.context_window || ctx, output: out },
+    };
+  }
+  return result;
+}
+
+function prettifyName(id) {
+  return id
+    .replace(/[@/]/g, " ")
+    .split(/[-_]/)
+    .filter(Boolean)
+    .map((w) => {
+      const lower = w.toLowerCase();
+      if (["glm", "api", "v4", "v3", "v2", "v5", "gpt", "m3"].includes(lower)) {
+        return w.toUpperCase();
+      }
+      return w.charAt(0).toUpperCase() + w.slice(1);
+    })
+    .join(" ");
+}
+
+/** @param {string} apiKey @param {object} models */
+export function buildProvider(apiKey, models) {
+  return {
+    npm: NPM_PACKAGE,
+    name: PROVIDER_NAME,
+    options: { baseURL: BASE_URL, apiKey },
+    models,
+  };
+}
+
+/** @param {object} config @param {string} apiKey @param {object} models */
+export function upsertProvider(config, apiKey, models) {
+  const next = { ...config };
+  if (!next.provider) next.provider = {};
+  next.provider[PROVIDER_ID] = buildProvider(apiKey, models);
+  return next;
+}
+
+/** @param {object} config */
+export function removeProvider(config) {
+  const next = { ...config };
+  if (next.provider && PROVIDER_ID in next.provider) {
+    delete next.provider[PROVIDER_ID];
+  }
+  return next;
+}
+
+// ============= ADAPTER INTERFACE =============
+
+export const opencodeAgent = {
+  id: "opencode",
+  name: "OpenCode",
+  supportsMultipleModels: true,
+
+  detect() {
+    return existsSync(getConfigPath());
+  },
+
+  isConfigured() {
+    const { config } = readConfig();
+    return hasProvider(config);
+  },
+
+  getStatus() {
+    const { config, path } = readConfig();
+    const provider = getProvider(config);
+    if (!provider) {
+      return { configured: false, path, models: [], apiKey: null };
+    }
+    const models = provider.models ? Object.keys(provider.models) : [];
+    const apiKey = provider.options?.apiKey || null;
+    return { configured: true, path, models, apiKey };
+  },
+
+  configure({ apiKey, models, primaryModel }) {
+    const { config, path } = readConfig();
+    const modelsObj = buildModels(models);
+    const newConfig = upsertProvider(config, apiKey, modelsObj);
+    writeConfig(newConfig, path);
+    return { path, modelsCount: models.length };
+  },
+
+  changeKey(apiKey) {
+    const { config, path } = readConfig();
+    if (!hasProvider(config)) {
+      throw new Error("NOITON não está configurado no OpenCode");
+    }
+    const provider = config.provider[PROVIDER_ID];
+    provider.options = provider.options || {};
+    provider.options.apiKey = apiKey;
+    writeConfig(config, path);
+    return { path };
+  },
+
+  refresh(models) {
+    const { config, path } = readConfig();
+    if (!hasProvider(config)) {
+      throw new Error("NOITON não está configurado no OpenCode");
+    }
+    const provider = config.provider[PROVIDER_ID];
+    provider.models = buildModels(models);
+    writeConfig(config, path);
+    return { path, modelsCount: models.length };
+  },
+
+  remove() {
+    const { config, path } = readConfig();
+    if (!hasProvider(config)) return { path, removed: false };
+    const newConfig = removeProvider(config);
+    writeConfig(newConfig, path);
+    return { path, removed: true };
+  },
+};

package/src/lib/detect.js

@@ -0,0 +1,286 @@
+/**
+ * NOITON Agent Detection
+ *
+ * Detects which AI coding agents are installed on the system by:
+ *   1. Checking if the CLI binary is on PATH (which)
+ *   2. Checking if the config file exists
+ *
+ * Returns a list of detected agents with metadata.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import { c } from "../constants.js";
+
+const HOME = homedir();
+const XDG = process.env.XDG_CONFIG_HOME || join(HOME, ".config");
+
+/**
+ * Check if a binary is available on PATH.
+ * @param {string} bin
+ * @returns {boolean}
+ */
+function hasBin(bin) {
+  try {
+    execSync(`which ${bin} 2>/dev/null`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get version of a CLI binary (best-effort).
+ * @param {string} bin
+ * @returns {string|null}
+ */
+function getBinVersion(bin) {
+  const flags = ["--version", "-v"];
+  for (const flag of flags) {
+    try {
+      const out = execSync(`${bin} ${flag} 2>/dev/null`, {
+        encoding: "utf8",
+        timeout: 5000,
+      }).trim();
+      // Extract first version-like token
+      const match = out.match(/(\d+\.\d+(?:\.\d+)?(?:-\w+)?)/);
+      if (match) return match[1];
+      return out.split("\n")[0];
+    } catch {
+      // try next flag
+    }
+  }
+  return null;
+}
+
+/**
+ * Get latest version of an npm package (best-effort).
+ * @param {string} pkg
+ * @returns {string|null}
+ */
+function getNpmLatest(pkg) {
+  try {
+    const out = execSync(`npm view ${pkg} version 2>/dev/null`, {
+      encoding: "utf8",
+      timeout: 8000,
+    }).trim();
+    const match = out.match(/(\d+\.\d+(?:\.\d+)?)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compare two semver-like version strings.
+ * Returns: 1 if a > b, -1 if a < b, 0 if equal.
+ * @param {string} a
+ * @param {string} b
+ */
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const va = pa[i] || 0;
+    const vb = pb[i] || 0;
+    if (va > vb) return 1;
+    if (va < vb) return -1;
+  }
+  return 0;
+}
+
+// ============= AGENT DEFINITIONS =============
+
+/**
+ * Registry of all supported agents.
+ * Each entry describes how to detect the agent and where its config lives.
+ */
+export const AGENT_REGISTRY = [
+  {
+    id: "opencode",
+    name: "OpenCode",
+    type: "CLI",
+    bin: "opencode",
+    npmPkg: "opencode-ai",
+    installMethod: "script",
+    installCmd: "curl -fsSL https://opencode.ai/install | bash",
+    configPath: join(XDG, "opencode", "opencode.json"),
+    supportsMultipleModels: true,
+    description: "Programador IA que escreve código junto com você",
+    useCase: "programming",
+  },
+  {
+    id: "hermes",
+    name: "Hermes",
+    type: "CLI",
+    bin: "hermes",
+    npmPkg: null,
+    installMethod: "pip",
+    installCmd: "pip install nous-hermes",
+    configPath: join(HOME, ".hermes", "config.yaml"),
+    envPath: join(HOME, ".hermes", ".env"),
+    supportsMultipleModels: false,
+    description: "Assistente que faz tarefas e se integra com apps",
+    useCase: "assistant",
+  },
+  {
+    id: "openclaw",
+    name: "OpenClaw",
+    type: "CLI",
+    bin: "openclaw",
+    npmPkg: null,
+    installMethod: null,
+    installCmd: null,
+    configPath: join(HOME, ".openclaw", "openclaw.json"),
+    supportsMultipleModels: true,
+    description: "Agente de IA open-source com providers customizáveis",
+    useCase: "programming",
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    type: "VSCode Extension",
+    bin: null,
+    npmPkg: null,
+    installMethod: null,
+    installCmd: null,
+    configPath: join(XDG, "Code", "User", "settings.json"),
+    supportsMultipleModels: true,
+    description: "Extensão VS Code para programação com IA",
+    useCase: "programming",
+  },
+  {
+    id: "aider",
+    name: "Aider",
+    type: "CLI",
+    bin: "aider",
+    npmPkg: null,
+    installMethod: "pip",
+    installCmd: "pip install aider-chat",
+    configPath: join(HOME, ".aider.conf.yml"),
+    supportsMultipleModels: false,
+    description: "Pair programmer de terminal que edita código com você",
+    useCase: "programming",
+  },
+  {
+    id: "kilo",
+    name: "Kilo Code",
+    type: "CLI + VSCode",
+    bin: "kilo",
+    npmPkg: "@kilocode/cli",
+    installMethod: "npm",
+    installCmd: "npm install -g @kilocode/cli",
+    configPath: join(XDG, "kilo", "kilo.jsonc"),
+    supportsMultipleModels: true,
+    description: "Agente de IA com CLI e extensão VS Code",
+    useCase: "programming",
+  },
+  {
+    id: "kimi",
+    name: "Kimi Code",
+    type: "CLI + VSCode",
+    bin: "kimi",
+    npmPkg: null,
+    installMethod: null,
+    installCmd: null,
+    configPath: join(HOME, ".kimi-code", "config.toml"),
+    supportsMultipleModels: false,
+    description: "Agente de IA da Moonshot com CLI e VS Code",
+    useCase: "programming",
+  },
+];
+
+/**
+ * Detect all installed agents.
+ * @returns {Array} detected agents with status info
+ */
+export function detectAgents() {
+  const detected = [];
+  for (const agent of AGENT_REGISTRY) {
+    const binFound = agent.bin ? hasBin(agent.bin) : false;
+    const configFound = existsSync(agent.configPath);
+    const installed = binFound || configFound;
+
+    if (installed) {
+      const version = binFound ? getBinVersion(agent.bin) : null;
+      detected.push({
+        ...agent,
+        installed: true,
+        version,
+        binFound,
+        configFound,
+      });
+    }
+  }
+  return detected;
+}
+
+/**
+ * Check if a specific agent is installed.
+ * @param {string} id
+ * @returns {boolean}
+ */
+export function isAgentInstalled(id) {
+  const agent = AGENT_REGISTRY.find((a) => a.id === id);
+  if (!agent) return false;
+  const binFound = agent.bin ? hasBin(agent.bin) : false;
+  const configFound = existsSync(agent.configPath);
+  return binFound || configFound;
+}
+
+/**
+ * Get the OpenCode agent specifically (most common case).
+ * Checks version and whether an update is available.
+ * @returns {object|null}
+ */
+export function getOpenCodeStatus() {
+  const agent = AGENT_REGISTRY.find((a) => a.id === "opencode");
+  if (!agent) return null;
+
+  const binFound = hasBin("opencode");
+  const configFound = existsSync(agent.configPath);
+  const installed = binFound || configFound;
+
+  if (!installed) return null;
+
+  const version = binFound ? getBinVersion("opencode") : null;
+  const latest = binFound ? getNpmLatest("opencode-ai") : null;
+  const updateAvailable =
+    version && latest ? compareVersions(latest, version) > 0 : false;
+
+  return {
+    ...agent,
+    installed: true,
+    version,
+    latest,
+    updateAvailable,
+    binFound,
+    configFound,
+  };
+}
+
+/**
+ * Get agents that can be auto-installed.
+ * @returns {Array}
+ */
+export function getInstallableAgents() {
+  return AGENT_REGISTRY.filter((a) => a.installCmd !== null);
+}
+
+/**
+ * Get the recommended agent for a given use case.
+ * @param {"programming"|"assistant"} useCase
+ * @returns {object|null}
+ */
+export function getRecommendedAgent(useCase) {
+  // Prefer OpenCode for programming, Hermes for assistant
+  if (useCase === "programming") {
+    return AGENT_REGISTRY.find((a) => a.id === "opencode");
+  }
+  if (useCase === "assistant") {
+    return AGENT_REGISTRY.find((a) => a.id === "hermes");
+  }
+  return AGENT_REGISTRY.find((a) => a.id === "opencode");
+}