@aliyunrds/ctxdb 0.0.1

package/dist/chunk-L4YJ7LDI.js

@@ -0,0 +1,395 @@
+#!/usr/bin/env node
+
+// src/lib/http-client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var CtxdbError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CtxdbError";
+  }
+};
+var AuthError = class extends CtxdbError {
+  constructor(message = "Unauthorized (HTTP 401) \u2014 check api_key") {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+var NotFoundError = class extends CtxdbError {
+  path;
+  constructor(path) {
+    super(`Not found: ${path}`);
+    this.name = "NotFoundError";
+    this.path = path;
+  }
+};
+var APIError = class extends CtxdbError {
+  path;
+  detail;
+  constructor(path, detail) {
+    super(`API error at ${path}: ${detail}`);
+    this.name = "APIError";
+    this.path = path;
+    this.detail = detail;
+  }
+};
+var CtxdbHttpError = class extends CtxdbError {
+  status;
+  detail;
+  constructor(status, detail) {
+    super(`HTTP ${status}: ${detail}`);
+    this.name = "CtxdbHttpError";
+    this.status = status;
+    this.detail = detail;
+  }
+};
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  userAgent;
+  extraHeaders;
+  fetchImpl;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.userAgent = opts.userAgent ?? "ctxdb-cli/0.0.1";
+    this.extraHeaders = { ...opts.extraHeaders ?? {} };
+    const f = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.fetchImpl = f;
+  }
+  buildHeaders(contentType) {
+    const h = {
+      Authorization: `Token ${this.apiKey}`,
+      "User-Agent": this.userAgent,
+      ...this.extraHeaders
+    };
+    if (contentType) h["Content-Type"] = contentType;
+    return h;
+  }
+  async doRequest(method, path, init = {}) {
+    let url = `${this.baseUrl}${path}`;
+    if (init.params) {
+      const qs = new URLSearchParams();
+      for (const [k, v] of Object.entries(init.params)) {
+        if (v !== void 0 && v !== null) qs.append(k, String(v));
+      }
+      const s = qs.toString();
+      if (s) url = `${url}?${s}`;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      let resp;
+      try {
+        resp = await this.fetchImpl(url, {
+          method,
+          headers: this.buildHeaders(init.contentType),
+          body: init.body,
+          signal: controller.signal
+        });
+      } catch (err) {
+        if (err?.name === "AbortError") {
+          throw new CtxdbError(`request timeout after ${this.timeoutMs}ms: ${url}`);
+        }
+        throw new CtxdbError(`network error contacting ${url}: ${err?.message ?? err}`);
+      }
+      if (resp.status === 204) return {};
+      let text;
+      try {
+        text = await resp.text();
+      } catch (err) {
+        if (err?.name === "AbortError") {
+          throw new CtxdbError(`request timeout after ${this.timeoutMs}ms (body read): ${url}`);
+        }
+        throw new CtxdbError(`network error reading body from ${url}: ${err?.message ?? err}`);
+      }
+      if (!resp.ok) {
+        const detail = extractErrorDetail(text, `HTTP ${resp.status}`);
+        if (resp.status === 401) throw new AuthError();
+        if (resp.status === 404) throw new NotFoundError(path);
+        if (resp.status === 400) throw new APIError(path, detail);
+        throw new CtxdbHttpError(resp.status, detail);
+      }
+      if (!text) return {};
+      return maybeJson(text);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ---------- Convenience verbs ----------
+  get(path, params) {
+    return this.doRequest("GET", path, { params });
+  }
+  postJson(path, body, params) {
+    return this.doRequest("POST", path, {
+      body: JSON.stringify(body ?? {}),
+      contentType: "application/json",
+      params
+    });
+  }
+  putJson(path, body) {
+    return this.doRequest("PUT", path, {
+      body: JSON.stringify(body),
+      contentType: "application/json"
+    });
+  }
+  delete(path, params) {
+    return this.doRequest("DELETE", path, { params });
+  }
+  /**
+   * POST multipart/form-data using runtime-native FormData.
+   *
+   * `fields` are appended as text values; `files` are appended as Blob
+   * with a filename. We intentionally do NOT pass a `Content-Type`
+   * header — when fetch sees a FormData body it sets the multipart
+   * boundary itself.
+   */
+  postMultipart(path, fields = {}, files = {}) {
+    const fd = new FormData();
+    for (const [name, value] of Object.entries(fields)) {
+      fd.append(name, value);
+    }
+    for (const [name, part] of Object.entries(files)) {
+      const blob = part.content instanceof Blob ? part.content : new Blob([part.content], { type: part.mimeType });
+      fd.append(name, blob, part.filename);
+    }
+    return this.doRequest("POST", path, { body: fd });
+  }
+};
+function maybeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function extractErrorDetail(text, fallback) {
+  if (!text) return fallback;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return text || fallback;
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const obj = parsed;
+    for (const k of ["detail", "message", "error"]) {
+      const v = obj[k];
+      if (typeof v === "string" && v) return v;
+    }
+    return JSON.stringify(parsed);
+  }
+  return String(parsed);
+}
+
+// src/lib/agents.ts
+import { homedir } from "os";
+import { join } from "path";
+var SUPPORTED_AGENTS = ["qoder", "codex", "claude"];
+function isAgent(v) {
+  return typeof v === "string" && SUPPORTED_AGENTS.includes(v);
+}
+function agentHomeDir(agent) {
+  switch (agent) {
+    case "qoder":
+      return join(homedir(), ".qoder");
+    case "codex":
+      return join(homedir(), ".codex");
+    case "claude":
+      return join(homedir(), ".claude");
+  }
+}
+function agentFromEnv(env = process.env) {
+  return isAgent(env.CTXDB_AGENT) ? env.CTXDB_AGENT : "qoder";
+}
+function agentFromArgvWithFallback(argv = process.argv.slice(2), env = process.env) {
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === "--agent" && isAgent(argv[i + 1])) {
+      return { agent: argv[i + 1], fellBack: false };
+    }
+    if (tok.startsWith("--agent=")) {
+      const raw = tok.slice("--agent=".length);
+      if (isAgent(raw)) return { agent: raw, fellBack: false };
+    }
+  }
+  return { agent: agentFromEnv(env), fellBack: true };
+}
+
+// src/lib/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+function defaultConfigPath() {
+  return join2(homedir2(), ".ctxdb", "ctxdb.json");
+}
+var DEFAULT_CONFIG_PATH = join2(homedir2(), ".ctxdb", "ctxdb.json");
+var DEFAULT_BASE_URL = "https://context-database.aliyuncs.com";
+var DEFAULT_USER_ID = "default";
+var DEFAULT_TOP_K = 5;
+var DEFAULT_THRESHOLD = 0.4;
+var DEFAULT_KNOWLEDGE_TOP_K = 6;
+function isComplete(cfg) {
+  return Boolean(cfg.apiKey && cfg.baseUrl);
+}
+function resolveConfigAgent(options = {}) {
+  if (isAgent(options.agent)) return options.agent;
+  return agentFromEnv(options.env);
+}
+function coerceInt(v, fallback) {
+  if (v === null || v === void 0 || v === "") return fallback;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? Math.trunc(n) : fallback;
+}
+function coerceFloat(v, fallback) {
+  if (v === null || v === void 0 || v === "") return fallback;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+function coerceBool(v, fallback) {
+  if (typeof v === "boolean") return v;
+  if (v === void 0 || v === null) return fallback;
+  return Boolean(v);
+}
+function readRaw(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function agentRawFromFile(raw, agent) {
+  const agents = raw.agents;
+  if (agents && typeof agents === "object" && !Array.isArray(agents)) {
+    const candidate = agents[agent];
+    if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+  return {};
+}
+function isV2Schema(raw) {
+  if (Object.keys(raw).length === 0) return true;
+  return raw.version === 2 && raw.agents !== null && typeof raw.agents === "object" && !Array.isArray(raw.agents);
+}
+function configFromDisk(raw) {
+  return {
+    apiKey: typeof raw.api_key === "string" && raw.api_key ? raw.api_key : null,
+    baseUrl: typeof raw.base_url === "string" && raw.base_url ? String(raw.base_url).replace(/\/+$/, "") : DEFAULT_BASE_URL,
+    userId: typeof raw.user_id === "string" && raw.user_id ? raw.user_id : DEFAULT_USER_ID,
+    autoCapture: coerceBool(raw.auto_capture, true),
+    autoRecall: coerceBool(raw.auto_recall, true),
+    warmupRecall: coerceBool(raw.warmup_recall, true),
+    recallKnowledge: coerceBool(raw.recall_knowledge, false),
+    topK: coerceInt(raw.top_k, DEFAULT_TOP_K),
+    threshold: coerceFloat(raw.threshold, DEFAULT_THRESHOLD),
+    knowledgeTopK: coerceInt(raw.knowledge_top_k, DEFAULT_KNOWLEDGE_TOP_K),
+    debug: coerceBool(raw.debug, false)
+  };
+}
+function applyEnv(cfg, env) {
+  if (env.CTXDB_API_KEY) cfg.apiKey = env.CTXDB_API_KEY;
+  if (env.CTXDB_BASE_URL) cfg.baseUrl = env.CTXDB_BASE_URL.replace(/\/+$/, "");
+  if (env.CTXDB_USER_ID) cfg.userId = env.CTXDB_USER_ID;
+  return cfg;
+}
+function load(options = {}) {
+  const path = options.path ?? defaultConfigPath();
+  const env = options.env ?? process.env;
+  const agent = resolveConfigAgent({ agent: options.agent, env });
+  const raw = readRaw(path);
+  if (!isV2Schema(raw)) {
+    try {
+      process.stderr.write(
+        `[ctxdb] config schema invalid at ${path}, treating as first-time install
+`
+      );
+    } catch {
+    }
+    return applyEnv(configFromDisk({}), env);
+  }
+  return applyEnv(configFromDisk(agentRawFromFile(raw, agent)), env);
+}
+function configToDisk(cfg) {
+  return {
+    api_key: cfg.apiKey,
+    base_url: cfg.baseUrl,
+    user_id: cfg.userId,
+    auto_capture: cfg.autoCapture,
+    auto_recall: cfg.autoRecall,
+    warmup_recall: cfg.warmupRecall,
+    recall_knowledge: cfg.recallKnowledge,
+    top_k: cfg.topK,
+    threshold: cfg.threshold,
+    knowledge_top_k: cfg.knowledgeTopK,
+    debug: cfg.debug
+  };
+}
+function removeAgent(agent, path, options = {}) {
+  const target = path ?? defaultConfigPath();
+  if (!existsSync(target)) {
+    return { removed: false, remainingAgents: [], fileDeleted: false };
+  }
+  const raw = readRaw(target);
+  if (!isV2Schema(raw) || !raw.agents || typeof raw.agents !== "object" || Array.isArray(raw.agents)) {
+    return { removed: false, remainingAgents: [], fileDeleted: false };
+  }
+  const agents = { ...raw.agents };
+  if (!(agent in agents)) {
+    return {
+      removed: false,
+      remainingAgents: Object.keys(agents),
+      fileDeleted: false
+    };
+  }
+  delete agents[agent];
+  const remaining = Object.keys(agents);
+  if (remaining.length === 0 && !options.keepEmptyShell) {
+    try {
+      unlinkSync(target);
+      return { removed: true, remainingAgents: [], fileDeleted: true };
+    } catch {
+    }
+  }
+  const onDisk = { version: 2, agents };
+  writeFileSync(target, JSON.stringify(onDisk, null, 2) + "\n", "utf-8");
+  return { removed: true, remainingAgents: remaining, fileDeleted: false };
+}
+function save(cfg, path, options = {}) {
+  const target = path ?? defaultConfigPath();
+  const agent = resolveConfigAgent(options);
+  const raw = readRaw(target);
+  const validRaw = isV2Schema(raw) ? raw : {};
+  const existingAgents = validRaw.agents && typeof validRaw.agents === "object" && !Array.isArray(validRaw.agents) ? { ...validRaw.agents } : {};
+  const onDisk = {
+    version: 2,
+    agents: {
+      ...existingAgents,
+      [agent]: configToDisk(cfg)
+    }
+  };
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, JSON.stringify(onDisk, null, 2) + "\n", "utf-8");
+}
+
+export {
+  CtxdbError,
+  NotFoundError,
+  HttpClient,
+  SUPPORTED_AGENTS,
+  isAgent,
+  agentHomeDir,
+  agentFromEnv,
+  agentFromArgvWithFallback,
+  DEFAULT_BASE_URL,
+  DEFAULT_USER_ID,
+  isComplete,
+  load,
+  removeAgent,
+  save
+};