@doufunao123/cognee-admin 0.2.0

package/README.md

@@ -0,0 +1,84 @@
+# @doufunao123/cognee-admin
+
+Lightweight npm thin client for the Cognee API. It mirrors the Rust `cognee-admin` client commands, but ships as a Node.js CLI for `npx` usage.
+
+## Install
+
+```bash
+npm install -g @doufunao123/cognee-admin
+```
+
+Or run directly:
+
+```bash
+npx @doufunao123/cognee-admin describe
+```
+
+## Auth Sharing
+
+The npm CLI reads and writes the same auth file as the Rust CLI:
+
+```json
+{
+  "cognee_jwt": "eyJ...",
+  "admin_token": "ca_...",
+  "cognee_url": "https://cogneeapi.xiaomao.chat"
+}
+```
+
+Location: `~/.config/cognee-admin/auth.json`
+
+Resolution order:
+
+1. `--cognee-url` / `--cognee-jwt`
+2. `COGNEE_URL` / `COGNEE_JWT`
+3. `~/.config/cognee-admin/auth.json`
+4. Built-in default URL: `https://cogneeapi.xiaomao.chat`
+
+## Usage
+
+```bash
+cognee-admin login --username alice --password secret
+cognee-admin health --detailed
+cognee-admin dataset list
+cognee-admin data add --dataset docs "hello world"
+cognee-admin data add-file --dataset docs ./notes.md
+cognee-admin data add-dir --dataset docs --glob "*.md" ./content
+cognee-admin cognify --dataset-name docs --background
+cognee-admin search "agent memory" --datasets docs,notes --top-k 10
+cognee-admin search history
+cognee-admin config get
+cognee-admin config set '{"llm":{"provider":"openai","model":"gpt-5.4","api_key":"sk-..."}}'
+cognee-admin ontology list
+cognee-admin ontology upload --key game ./ontology.owl
+cognee-admin describe
+```
+
+## Output
+
+JSON is the default output format:
+
+```json
+{
+  "ok": true,
+  "command": "dataset.list",
+  "data": {
+    "items": []
+  }
+}
+```
+
+Use `--human` for readable output.
+
+## Commands
+
+- `health [--detailed] [--watch] [--interval N]`
+- `login --username X --password Y`
+- `dataset list|create|delete|delete-all|status|graph`
+- `data add|add-file|add-dir|list|delete|raw|update`
+- `cognify [--dataset-id X] [--dataset-name X] [--custom-prompt Y] [--custom-prompt-file path] [--background] [--chunks-per-batch N]`
+- `search <query> [--search-type X] [--top-k N] [--datasets a,b] [--verbose]`
+- `search history`
+- `config get|set`
+- `ontology upload|list`
+- `describe [command]`

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1107 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command10 } from "commander";
+
+// src/commands/cognify.ts
+import { readFile as readFile2 } from "fs/promises";
+import { Command } from "commander";
+
+// src/errors.ts
+var CogneeAdminError = class extends Error {
+  code;
+  exitCode;
+  suggestion;
+  constructor(message, options) {
+    super(message);
+    this.name = "CogneeAdminError";
+    this.code = options.code;
+    this.exitCode = options.exitCode ?? 1;
+    this.suggestion = options.suggestion;
+  }
+};
+function configError(message, suggestion) {
+  return new CogneeAdminError(message, {
+    code: "CONFIG_ERROR",
+    exitCode: 1,
+    suggestion: suggestion ?? "Run cognee-admin health to verify configuration"
+  });
+}
+function notFoundError(message) {
+  return new CogneeAdminError(message, {
+    code: "NOT_FOUND",
+    exitCode: 1
+  });
+}
+function apiError(message, suggestion) {
+  return new CogneeAdminError(message, {
+    code: "COGNEE_API_ERROR",
+    exitCode: 3,
+    suggestion: suggestion ?? "Check if Cognee is running: cognee-admin health"
+  });
+}
+function httpClientError(message, suggestion) {
+  return new CogneeAdminError(message, {
+    code: "HTTP_CLIENT_ERROR",
+    exitCode: 3,
+    suggestion: suggestion ?? "Check network connectivity to Cognee API"
+  });
+}
+function internalError(message) {
+  return new CogneeAdminError(message, {
+    code: "INTERNAL_ERROR",
+    exitCode: 2
+  });
+}
+function normalizeError(error2) {
+  if (error2 instanceof CogneeAdminError) {
+    return error2;
+  }
+  if (error2 instanceof Error) {
+    return internalError(error2.message);
+  }
+  return internalError(String(error2));
+}
+
+// src/client.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+var CogneeClient = class {
+  constructor(baseUrl, jwt) {
+    this.baseUrl = baseUrl;
+    this.jwt = jwt;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, { body });
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+  async uploadFiles(datasetName, files) {
+    const form = new FormData();
+    form.set("datasetName", datasetName);
+    for (const filePath of files) {
+      form.append("data", await fileBlobFromPath(filePath), basename(filePath));
+    }
+    return this.request("POST", "/api/v1/add", { form });
+  }
+  async health() {
+    return this.get("/health");
+  }
+  async healthDetailed() {
+    return this.get("/health/detailed");
+  }
+  async login(username, password) {
+    const body = new URLSearchParams({ username, password });
+    return this.request("POST", "/api/v1/auth/login", {
+      body,
+      headers: {
+        "content-type": "application/x-www-form-urlencoded"
+      }
+    });
+  }
+  async datasets() {
+    return this.get("/api/v1/datasets");
+  }
+  async createDataset(name) {
+    return this.post("/api/v1/datasets", { name });
+  }
+  async deleteDataset(id) {
+    return this.delete(`/api/v1/datasets/${encodeURIComponent(id)}`);
+  }
+  async deleteAllDatasets() {
+    return this.delete("/api/v1/datasets");
+  }
+  async datasetStatus() {
+    return this.get("/api/v1/datasets/status");
+  }
+  async datasetGraph(id) {
+    return this.get(`/api/v1/datasets/${encodeURIComponent(id)}/graph`);
+  }
+  async datasetData(id) {
+    return this.get(`/api/v1/datasets/${encodeURIComponent(id)}/data`);
+  }
+  async deleteData(datasetId, dataId) {
+    return this.delete(
+      `/api/v1/datasets/${encodeURIComponent(datasetId)}/data/${encodeURIComponent(dataId)}`
+    );
+  }
+  async rawData(datasetId, dataId) {
+    return this.get(
+      `/api/v1/datasets/${encodeURIComponent(datasetId)}/data/${encodeURIComponent(dataId)}/raw`
+    );
+  }
+  async addData(datasetName, content) {
+    const form = new FormData();
+    form.set("datasetName", datasetName);
+    form.append("data", new Blob([content], { type: "text/plain" }), "inline.txt");
+    return this.request("POST", "/api/v1/add", { form });
+  }
+  async uploadFile(datasetName, filePath) {
+    return this.uploadFiles(datasetName, [filePath]);
+  }
+  async updateData(datasetId, dataId, filePath) {
+    const form = new FormData();
+    form.append("data", await fileBlobFromPath(filePath), basename(filePath));
+    return this.request("PATCH", "/api/v1/update", {
+      form,
+      query: {
+        dataset_id: datasetId,
+        data_id: dataId
+      }
+    });
+  }
+  async cognify(options) {
+    return this.post("/api/v1/cognify", options);
+  }
+  async search(query, options = {}) {
+    return this.post("/api/v1/search", {
+      query,
+      search_type: options.search_type ?? "INSIGHTS",
+      top_k: options.top_k ?? 5,
+      ...options.datasets && options.datasets.length > 0 ? { datasets: options.datasets } : {}
+    });
+  }
+  async searchHistory() {
+    return this.get("/api/v1/search");
+  }
+  async getSettings() {
+    return this.get("/api/v1/settings");
+  }
+  async saveSettings(settings) {
+    return this.post("/api/v1/settings", settings);
+  }
+  async uploadOntology(key, filePath) {
+    const form = new FormData();
+    form.set("ontology_key", key);
+    form.append("ontology_file", await fileBlobFromPath(filePath), basename(filePath));
+    return this.request("POST", "/api/v1/ontologies", { form });
+  }
+  async listOntologies() {
+    return this.get("/api/v1/ontologies");
+  }
+  async request(method, path, options = {}) {
+    const url = new URL(path, ensureTrailingSlash(this.baseUrl));
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    const headers = new Headers(options.headers);
+    if (this.jwt) {
+      headers.set("authorization", `Bearer ${this.jwt}`);
+    }
+    let body;
+    if (options.form) {
+      body = options.form;
+    } else if (options.body instanceof URLSearchParams) {
+      body = options.body;
+    } else if (options.body !== void 0) {
+      headers.set("content-type", "application/json");
+      body = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await fetch(url, { method, headers, body });
+    } catch (error2) {
+      throw httpClientError(
+        error2 instanceof Error ? error2.message : String(error2)
+      );
+    }
+    const text = await response.text();
+    const payload = parseResponse(text);
+    if (!response.ok) {
+      const preview = typeof payload === "string" ? payload : JSON.stringify(payload);
+      if (response.status === 404) {
+        throw notFoundError(`HTTP 404 - ${truncate(preview, 512)}`);
+      }
+      throw apiError(`HTTP ${response.status} - ${truncate(preview, 512)}`);
+    }
+    return payload;
+  }
+};
+async function fileBlobFromPath(filePath) {
+  let content;
+  try {
+    content = await readFile(filePath);
+  } catch (error2) {
+    throw configError(
+      `Failed to read file ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+  const arrayBuffer = content.buffer.slice(
+    content.byteOffset,
+    content.byteOffset + content.byteLength
+  );
+  return new Blob([arrayBuffer]);
+}
+function ensureTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+function parseResponse(text) {
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength)}...[truncated]`;
+}
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/meta.ts
+var CLI_NAME = "cognee-admin";
+var CLI_VERSION = "0.2.0";
+var CLI_DESCRIPTION = "Cognee knowledge engine management CLI";
+var DEFAULT_COGNEE_URL = "https://cogneeapi.xiaomao.chat";
+
+// src/config.ts
+function configDir() {
+  return join(homedir(), ".config", "cognee-admin");
+}
+function configPath() {
+  return join(configDir(), "auth.json");
+}
+function loadAuthConfig() {
+  const path = configPath();
+  if (!existsSync(path)) {
+    return {};
+  }
+  const content = readFileSync(path, "utf8");
+  if (!content.trim()) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (hasCurrentAuthFields(parsed)) {
+      return {
+        cognee_jwt: parsed.cognee_jwt,
+        admin_token: parsed.admin_token,
+        cognee_url: parsed.cognee_url
+      };
+    }
+    const migrated = {
+      cognee_url: parsed.cognee_url
+    };
+    if (parsed.token) {
+      if (parsed.token.startsWith("ca_")) {
+        migrated.admin_token = parsed.token;
+      } else {
+        migrated.cognee_jwt = parsed.token;
+      }
+    }
+    return migrated;
+  } catch (error2) {
+    throw configError(
+      `Failed to parse auth config at ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+}
+function saveAuthConfig(config) {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  chmodSync(path, 384);
+}
+function resolveCogneeUrl(overrides) {
+  return overrides?.cogneeUrl ?? process.env.COGNEE_URL ?? loadAuthConfig().cognee_url ?? DEFAULT_COGNEE_URL;
+}
+function resolveCogneeJwt(overrides) {
+  return overrides?.cogneeJwt ?? process.env.COGNEE_JWT ?? loadAuthConfig().cognee_jwt;
+}
+function hasCurrentAuthFields(value) {
+  return Object.hasOwn(value, "cognee_jwt") || Object.hasOwn(value, "admin_token") || Object.hasOwn(value, "cognee_url");
+}
+
+// src/output.ts
+function success(command, data) {
+  return { ok: true, command, data };
+}
+function error(command, code, message, suggestion) {
+  return {
+    ok: false,
+    command,
+    error: { code, message, ...suggestion ? { suggestion } : {} }
+  };
+}
+function output(result, human = false) {
+  if (human) {
+    if (result.ok) {
+      console.log(`\u2713 ${result.command}`);
+      console.log(formatHuman(result.data));
+    } else {
+      console.error(`\u2717 ${result.command}: ${result.error.message}`);
+      if (result.error.suggestion) {
+        console.error(`  \u2192 ${result.error.suggestion}`);
+      }
+    }
+  } else {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  }
+}
+function filterFields(data, fields) {
+  if (!fields) return data;
+  const allowed = new Set(fields.split(",").map((f) => f.trim()));
+  const filtered = {};
+  for (const key of allowed) {
+    if (key in data) {
+      filtered[key] = data[key];
+    }
+  }
+  return filtered;
+}
+function formatHuman(data, indent = 0) {
+  if (data === null || data === void 0) return "";
+  if (typeof data === "string") return " ".repeat(indent) + data;
+  if (typeof data !== "object") return " ".repeat(indent) + String(data);
+  const pad = " ".repeat(indent);
+  if (Array.isArray(data)) {
+    return data.map((item) => formatHuman(item, indent + 2)).join("\n");
+  }
+  return Object.entries(data).map(([key, val]) => {
+    if (typeof val === "object" && val !== null) {
+      return `${pad}${key}:
+${formatHuman(val, indent + 2)}`;
+    }
+    return `${pad}${key}: ${val}`;
+  }).join("\n");
+}
+
+// src/commands/common.ts
+function getGlobalOptions(command) {
+  return command.optsWithGlobals();
+}
+function createContext(command, requireAuth = true) {
+  const globals = getGlobalOptions(command);
+  const url = resolveCogneeUrl({ cogneeUrl: globals.cogneeUrl });
+  const jwt = resolveCogneeJwt({ cogneeJwt: globals.cogneeJwt });
+  if (requireAuth && !jwt) {
+    throw configError(
+      "Cognee JWT is required. Use --cognee-jwt, set COGNEE_JWT, or run cognee-admin login.",
+      "Run cognee-admin login --username <user> --password <pass>"
+    );
+  }
+  return {
+    client: new CogneeClient(url, jwt),
+    human: Boolean(globals.human),
+    fields: globals.fields
+  };
+}
+function printSuccess(commandName, data, ctx) {
+  const filtered = isRecord(data) ? filterFields(data, ctx.fields) : data;
+  output(success(commandName, filtered), ctx.human);
+}
+function printError(commandName, err, human = false) {
+  const normalized = normalizeError(err);
+  output(
+    error(commandName, normalized.code, normalized.message, normalized.suggestion),
+    human
+  );
+  process.exit(normalized.exitCode);
+}
+function loadSharedAuthConfig() {
+  return loadAuthConfig();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/commands/cognify.ts
+function createCognifyCommand() {
+  return new Command("cognify").description("Trigger cognification pipeline").option("--dataset-id <id>", "Optional dataset ID to cognify").option("--dataset-name <name>", "Optional dataset name to cognify").option("--custom-prompt <prompt>", "Override the default cognify prompt").option("--custom-prompt-file <path>", "Read custom prompt text from a file").option("--background", "Run cognify in background mode").option("--chunks-per-batch <count>", "Override chunks per batch for the pipeline").action(
+    async function(options) {
+      const ctx = createContext(this);
+      try {
+        if (options.datasetId && options.datasetName) {
+          throw configError("use either --dataset-id or --dataset-name, not both");
+        }
+        if (options.customPrompt && options.customPromptFile) {
+          throw configError("use either --custom-prompt or --custom-prompt-file, not both");
+        }
+        const datasets = options.datasetId ?? options.datasetName;
+        const customPrompt = options.customPromptFile ? await readFile2(options.customPromptFile, "utf8") : options.customPrompt;
+        const chunksPerBatch = options.chunksPerBatch ? Number.parseInt(options.chunksPerBatch, 10) : void 0;
+        if (options.chunksPerBatch && !Number.isFinite(chunksPerBatch)) {
+          throw configError("--chunks-per-batch must be a valid integer");
+        }
+        const data = await ctx.client.cognify({
+          ...datasets ? { datasets: [datasets] } : {},
+          ...customPrompt ? { custom_prompt: customPrompt } : {},
+          run_in_background: Boolean(options.background),
+          ...typeof chunksPerBatch === "number" ? { chunks_per_batch: chunksPerBatch } : {}
+        });
+        printSuccess("cognify", data, ctx);
+      } catch (error2) {
+        printError("cognify", error2, ctx.human);
+      }
+    }
+  );
+}
+
+// src/commands/config.ts
+import { Command as Command2 } from "commander";
+function createConfigCommand() {
+  const command = new Command2("config").description("Cognee settings management");
+  command.addCommand(
+    new Command2("get").description("Get current settings").action(async function() {
+      const ctx = createContext(this);
+      try {
+        printSuccess("config.get", await ctx.client.getSettings(), ctx);
+      } catch (error2) {
+        printError("config.get", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command2("set").description("Update settings").argument("<settings>", "Settings as JSON").action(async function(settings) {
+      const ctx = createContext(this);
+      try {
+        const parsed = JSON.parse(settings);
+        printSuccess("config.set", await ctx.client.saveSettings(parsed), ctx);
+      } catch (error2) {
+        if (error2 instanceof SyntaxError) {
+          printError("config.set", configError(`Invalid JSON: ${error2.message}`), ctx.human);
+        }
+        printError("config.set", error2, ctx.human);
+      }
+    })
+  );
+  return command;
+}
+
+// src/commands/data.ts
+import { readdir } from "fs/promises";
+import { basename as basename2, join as join2, relative } from "path";
+import { Command as Command3 } from "commander";
+var UPLOAD_BATCH_SIZE = 10;
+function createDataCommand() {
+  const command = new Command3("data").description("Data management within datasets");
+  command.addCommand(
+    new Command3("add").description("Add text data to a dataset").requiredOption("--dataset <name>", "Dataset name").argument("<content>", "Text content").action(async function(content, options) {
+      const ctx = createContext(this);
+      try {
+        printSuccess("data.add", await ctx.client.addData(options.dataset, content), ctx);
+      } catch (error2) {
+        printError("data.add", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command3("add-file").description("Upload a single file to a dataset").requiredOption("--dataset <name>", "Dataset name").argument("<path>", "File path to upload").action(async function(filePath, options) {
+      const ctx = createContext(this);
+      try {
+        printSuccess("data.add-file", await ctx.client.uploadFile(options.dataset, filePath), ctx);
+      } catch (error2) {
+        printError("data.add-file", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command3("add-dir").description("Upload matching files from a directory in batches of 10").requiredOption("--dataset <name>", "Dataset name").option("--glob <pattern>", "Glob pattern used to filter files", "*").argument("<dir>", "Directory to scan recursively").action(async function(dir, options) {
+      const ctx = createContext(this);
+      try {
+        const files = await collectMatchingFiles(dir, options.glob);
+        if (files.length === 0) {
+          throw notFoundError(`No files matched '${options.glob}' in ${dir}`);
+        }
+        let uploaded = 0;
+        let failed = 0;
+        const errors = [];
+        const totalBatches = Math.ceil(files.length / UPLOAD_BATCH_SIZE);
+        for (let index = 0; index < totalBatches; index += 1) {
+          const start = index * UPLOAD_BATCH_SIZE;
+          const batch = files.slice(start, start + UPLOAD_BATCH_SIZE);
+          console.error(
+            `[${index + 1}/${totalBatches}] Uploading ${batch.length} file(s) to ${options.dataset}`
+          );
+          try {
+            await ctx.client.uploadFiles(options.dataset, batch);
+            uploaded += batch.length;
+            console.error(
+              `[${index + 1}/${totalBatches}] Uploaded ${uploaded}/${files.length} file(s)`
+            );
+          } catch (batchError) {
+            console.error(
+              `[${index + 1}/${totalBatches}] Batch upload failed, retrying individually`
+            );
+            errors.push({ batch, error: errorMessage(batchError) });
+            for (const filePath of batch) {
+              try {
+                await ctx.client.uploadFile(options.dataset, filePath);
+                uploaded += 1;
+                console.error(`  OK ${relative(dir, filePath) || basename2(filePath)}`);
+              } catch (fileError) {
+                failed += 1;
+                errors.push({ path: filePath, error: errorMessage(fileError) });
+                console.error(`  FAIL ${relative(dir, filePath) || basename2(filePath)}: ${errorMessage(fileError)}`);
+              }
+            }
+          }
+        }
+        const summary = {
+          dataset: options.dataset,
+          directory: dir,
+          glob: options.glob,
+          batch_size: UPLOAD_BATCH_SIZE,
+          total: files.length,
+          uploaded,
+          failed,
+          skipped: 0,
+          errors
+        };
+        console.error(`Completed upload: success=${uploaded} failed=${failed} total=${files.length}`);
+        printSuccess("data.add-dir", summary, ctx);
+      } catch (error2) {
+        printError("data.add-dir", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command3("list").description("List data in a dataset").argument("<datasetId>", "Dataset ID").action(async function(datasetId) {
+      const ctx = createContext(this);
+      try {
+        printSuccess("data.list", await ctx.client.datasetData(datasetId), ctx);
+      } catch (error2) {
+        printError("data.list", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command3("delete").description("Delete data from a dataset").requiredOption("--dataset-id <id>", "Dataset ID").requiredOption("--data-id <id>", "Data ID").action(async function(options) {
+      const ctx = createContext(this);
+      try {
+        printSuccess(
+          "data.delete",
+          await ctx.client.deleteData(options.datasetId, options.dataId),
+          ctx
+        );
+      } catch (error2) {
+        printError("data.delete", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command3("raw").description("Get raw data content").requiredOption("--dataset-id <id>", "Dataset ID").requiredOption("--data-id <id>", "Data ID").action(async function(options) {
+      const ctx = createContext(this);
+      try {
+        printSuccess(
+          "data.raw",
+          await ctx.client.rawData(options.datasetId, options.dataId),
+          ctx
+        );
+      } catch (error2) {
+        printError("data.raw", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command3("update").description("Replace an existing data item with a new file").requiredOption("--dataset-id <id>", "Dataset ID").requiredOption("--data-id <id>", "Data ID").argument("<path>", "File path to upload").action(async function(filePath, options) {
+      const ctx = createContext(this);
+      try {
+        printSuccess(
+          "data.update",
+          await ctx.client.updateData(options.datasetId, options.dataId, filePath),
+          ctx
+        );
+      } catch (error2) {
+        printError("data.update", error2, ctx.human);
+      }
+    })
+  );
+  return command;
+}
+async function collectMatchingFiles(rootDir, globPattern) {
+  const matcher = createGlobMatcher(globPattern);
+  const files = [];
+  await visit(rootDir, rootDir, matcher, files);
+  files.sort((a, b) => a.localeCompare(b));
+  return files;
+}
+async function visit(rootDir, currentDir, matcher, files) {
+  let entries;
+  try {
+    entries = await readdir(currentDir, { withFileTypes: true });
+  } catch (error2) {
+    throw configError(
+      `Failed to read directory ${currentDir}: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+  for (const entry of entries) {
+    const fullPath = join2(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      await visit(rootDir, fullPath, matcher, files);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const relativePath = relative(rootDir, fullPath).split("\\").join("/");
+    if (matcher(relativePath, entry.name)) {
+      files.push(fullPath);
+    }
+  }
+}
+function createGlobMatcher(globPattern) {
+  if (!globPattern || globPattern.trim() === "") {
+    throw configError("Invalid glob pattern: pattern must not be empty");
+  }
+  const regex = globToRegExp(globPattern);
+  const hasSlash = globPattern.includes("/");
+  return (relativePath, baseName) => {
+    if (regex.test(relativePath)) {
+      return true;
+    }
+    return !hasSlash && regex.test(baseName);
+  };
+}
+function globToRegExp(globPattern) {
+  let regex = "^";
+  for (let i = 0; i < globPattern.length; i += 1) {
+    const char = globPattern[i];
+    const next = globPattern[i + 1];
+    if (char === "*") {
+      if (next === "*") {
+        regex += ".*";
+        i += 1;
+      } else {
+        regex += "[^/]*";
+      }
+      continue;
+    }
+    if (char === "?") {
+      regex += "[^/]";
+      continue;
+    }
+    if (char === "/") {
+      regex += "/";
+      continue;
+    }
+    regex += escapeRegExp(char);
+  }
+  regex += "$";
+  return new RegExp(regex);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function errorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+
+// src/commands/dataset.ts
+import { Command as Command4 } from "commander";
+function createDatasetCommand() {
+  const command = new Command4("dataset").description("Dataset management");
+  command.addCommand(
+    new Command4("list").description("List all datasets").action(async function() {
+      const ctx = createContext(this);
+      try {
+        printSuccess("dataset.list", await ctx.client.datasets(), ctx);
+      } catch (error2) {
+        printError("dataset.list", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command4("create").description("Create a new dataset").argument("<name>", "Dataset name").action(async function(name) {
+      const ctx = createContext(this);
+      try {
+        printSuccess("dataset.create", await ctx.client.createDataset(name), ctx);
+      } catch (error2) {
+        printError("dataset.create", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command4("delete").description("Delete a dataset").argument("<id>", "Dataset ID").action(async function(id) {
+      const ctx = createContext(this);
+      try {
+        printSuccess("dataset.delete", await ctx.client.deleteDataset(id), ctx);
+      } catch (error2) {
+        printError("dataset.delete", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command4("delete-all").description("Delete every dataset").option("--yes", "Confirm destructive delete-all operation").action(async function(options) {
+      const ctx = createContext(this);
+      try {
+        if (!options.yes) {
+          throw configError("refusing to delete all datasets: use --yes to confirm");
+        }
+        printSuccess("dataset.delete-all", await ctx.client.deleteAllDatasets(), ctx);
+      } catch (error2) {
+        printError("dataset.delete-all", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command4("status").description("Show dataset processing status").action(async function() {
+      const ctx = createContext(this);
+      try {
+        printSuccess("dataset.status", await ctx.client.datasetStatus(), ctx);
+      } catch (error2) {
+        printError("dataset.status", error2, ctx.human);
+      }
+    })
+  ).addCommand(
+    new Command4("graph").description("Get dataset knowledge graph").argument("<id>", "Dataset ID").action(async function(id) {
+      const ctx = createContext(this);
+      try {
+        printSuccess("dataset.graph", await ctx.client.datasetGraph(id), ctx);
+      } catch (error2) {
+        printError("dataset.graph", error2, ctx.human);
+      }
+    })
+  );
+  return command;
+}
+
+// src/commands/describe.ts
+import { Command as Command5 } from "commander";
+var SCHEMAS = {
+  health: {
+    description: "Check Cognee API health",
+    params: {
+      "--detailed": { type: "bool", default: false, description: "Include detailed system info" },
+      "--watch": { type: "bool", default: false, description: "Continuously poll until Ctrl+C" },
+      "--interval": { type: "u64", default: 30, description: "Polling interval in seconds for watch mode" }
+    }
+  },
+  login: {
+    description: "Authenticate with Cognee API",
+    params: {
+      "--username": { type: "string", required: true, description: "Login username" },
+      "--password": { type: "string", required: true, description: "Login password" }
+    }
+  },
+  dataset: {
+    description: "Dataset management",
+    subcommands: {
+      list: { description: "List all datasets" },
+      create: {
+        description: "Create a new dataset",
+        params: { name: { type: "string", required: true } }
+      },
+      delete: {
+        description: "Delete a dataset",
+        params: { id: { type: "string", required: true } }
+      },
+      "delete-all": {
+        description: "Delete every dataset",
+        params: {
+          "--yes": {
+            type: "bool",
+            required: true,
+            description: "Confirm destructive delete-all operation"
+          }
+        }
+      },
+      status: { description: "Show dataset processing status" },
+      graph: {
+        description: "Get dataset knowledge graph",
+        params: { id: { type: "string", required: true } }
+      }
+    }
+  },
+  data: {
+    description: "Data management within datasets",
+    subcommands: {
+      add: {
+        description: "Add text data to a dataset",
+        params: {
+          "--dataset": { type: "string", required: true, description: "Dataset name" },
+          content: { type: "string", required: true, description: "Text content" }
+        }
+      },
+      "add-file": {
+        description: "Upload a single file to a dataset",
+        params: {
+          "--dataset": { type: "string", required: true, description: "Dataset name" },
+          path: { type: "string", required: true, description: "File path to upload" }
+        }
+      },
+      "add-dir": {
+        description: "Upload matching files from a directory in batches of 10",
+        params: {
+          "--dataset": { type: "string", required: true, description: "Dataset name" },
+          "--glob": {
+            type: "string",
+            required: false,
+            default: "*",
+            description: "Glob pattern used to filter files"
+          },
+          dir: { type: "string", required: true, description: "Directory to scan recursively" }
+        }
+      },
+      list: {
+        description: "List data in a dataset",
+        params: { datasetId: { type: "string", required: true } }
+      },
+      delete: {
+        description: "Delete data from a dataset",
+        params: {
+          "--dataset-id": { type: "string", required: true },
+          "--data-id": { type: "string", required: true }
+        }
+      },
+      raw: {
+        description: "Get raw data content",
+        params: {
+          "--dataset-id": { type: "string", required: true },
+          "--data-id": { type: "string", required: true }
+        }
+      },
+      update: {
+        description: "Replace an existing data item with a new file",
+        params: {
+          "--dataset-id": { type: "string", required: true },
+          "--data-id": { type: "string", required: true },
+          path: { type: "string", required: true, description: "File path to upload" }
+        }
+      }
+    }
+  },
+  cognify: {
+    description: "Trigger cognification pipeline",
+    params: {
+      "--dataset-id": { type: "string", required: false, description: "Optional dataset ID to cognify" },
+      "--dataset-name": { type: "string", required: false, description: "Optional dataset name to cognify" },
+      "--custom-prompt": { type: "string", required: false, description: "Override the default cognify prompt" },
+      "--custom-prompt-file": { type: "path", required: false, description: "Read custom prompt text from a file" },
+      "--background": { type: "bool", default: false, description: "Run cognify in background mode" },
+      "--chunks-per-batch": { type: "u32", required: false, description: "Override chunks per batch for the pipeline" }
+    }
+  },
+  search: {
+    description: "Search the knowledge base",
+    params: {
+      query: { type: "string", required: true, description: "Search query unless using the history subcommand" },
+      "--search-type": { type: "string", default: "INSIGHTS", description: "Search type" },
+      "--top-k": { type: "u32", default: 5, description: "Number of results" },
+      "--datasets": { type: "string[]", required: false, description: "Comma-separated dataset names to filter by" },
+      "--verbose": { type: "bool", default: false, description: "Include request metadata in the response" }
+    },
+    subcommands: {
+      history: { description: "Fetch search history" }
+    }
+  },
+  config: {
+    description: "Cognee settings management",
+    subcommands: {
+      get: { description: "Get current settings" },
+      set: {
+        description: "Update settings",
+        params: { settings: { type: "string", required: true, description: "Settings as JSON" } }
+      }
+    }
+  },
+  ontology: {
+    description: "Ontology management",
+    subcommands: {
+      upload: {
+        description: "Upload an ontology OWL file",
+        params: {
+          "--key": { type: "string", required: true, description: "Ontology key to store under" },
+          file: { type: "path", required: true, description: "Path to the OWL file" }
+        }
+      },
+      list: { description: "List uploaded ontologies" }
+    }
+  },
+  describe: {
+    description: "Self-describe available commands (JSON Schema)",
+    params: {
+      command: { type: "string", required: false, description: "Specific command to describe" }
+    }
+  }
+};
+function createDescribeCommand() {
+  return new Command5("describe").description("Self-describe available commands (JSON Schema)").argument("[command]", "Specific command to describe").action(function(commandArg) {
+    const globals = this.optsWithGlobals();
+    if (!commandArg) {
+      output(
+        success("describe", {
+          name: CLI_NAME,
+          version: CLI_VERSION,
+          description: CLI_DESCRIPTION,
+          commands: SCHEMAS
+        }),
+        globals.human
+      );
+      return;
+    }
+    const schema = SCHEMAS[commandArg];
+    if (!schema) {
+      output(
+        success("describe", {
+          error: `Unknown command: ${commandArg}`,
+          available: Object.keys(SCHEMAS)
+        }),
+        globals.human
+      );
+      return;
+    }
+    output(success("describe", { command: commandArg, schema }), globals.human);
+  });
+}
+
+// src/commands/health.ts
+import { Command as Command6 } from "commander";
+function createHealthCommand() {
+  return new Command6("health").description("Check Cognee API health").option("--detailed", "Include detailed system info").option("--watch", "Continuously poll until Ctrl+C").option("--interval <seconds>", "Polling interval in seconds for watch mode", "30").action(async function(options) {
+    const ctx = createContext(this);
+    const interval = Number.parseInt(options.interval ?? "30", 10);
+    if (!Number.isFinite(interval) || interval < 1) {
+      printError("health", configError("--interval must be at least 1 second"), ctx.human);
+    }
+    try {
+      if (!options.watch) {
+        const data = options.detailed ? await ctx.client.healthDetailed() : await ctx.client.health();
+        printSuccess("health", data, ctx);
+        return;
+      }
+      let stopped = false;
+      const onSigint = () => {
+        stopped = true;
+      };
+      process.once("SIGINT", onSigint);
+      while (!stopped) {
+        const data = options.detailed ? await ctx.client.healthDetailed() : await ctx.client.health();
+        printSuccess("health", data, ctx);
+        await sleep(interval * 1e3);
+      }
+      process.removeListener("SIGINT", onSigint);
+      printSuccess(
+        "health",
+        { watch_stopped: true, interval_secs: interval },
+        ctx
+      );
+    } catch (error2) {
+      printError("health", error2, ctx.human);
+    }
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/login.ts
+import { Command as Command7 } from "commander";
+function createLoginCommand() {
+  return new Command7("login").description("Authenticate with Cognee API").requiredOption("--username <username>", "Login username").requiredOption("--password <password>", "Login password").action(async function(options) {
+    const globals = getGlobalOptions(this);
+    const ctx = createContext(this, false);
+    try {
+      const data = await ctx.client.login(options.username, options.password);
+      const token = typeof data === "object" && data !== null && "access_token" in data ? data.access_token : void 0;
+      if (typeof token !== "string" || token.length === 0) {
+        throw configError("No access_token in login response");
+      }
+      const current = loadSharedAuthConfig();
+      saveAuthConfig({
+        ...current,
+        cognee_jwt: token,
+        cognee_url: resolveCogneeUrl({ cogneeUrl: globals.cogneeUrl })
+      });
+      printSuccess("login", data, ctx);
+    } catch (error2) {
+      printError("login", error2, ctx.human);
+    }
+  });
+}
+
+// src/commands/ontology.ts
+import { Command as Command8 } from "commander";
+function createOntologyCommand() {
+  const command = new Command8("ontology").description("Ontology management");
+  command.addCommand(
+    new Command8("upload").description("Upload an ontology OWL file").requiredOption("--key <key>", "Ontology key to store under").argument("<file>", "Path to the OWL file").action(async function(file, options) {
+      const ctx = createContext(this);
+      try {
+        printSuccess("ontology.upload", await ctx.client.uploadOntology(options.key, file), ctx);
+      } catch (error2) {
+        printError("ontology.upload", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command8("list").description("List uploaded ontologies").action(async function() {
+      const ctx = createContext(this);
+      try {
+        printSuccess("ontology.list", await ctx.client.listOntologies(), ctx);
+      } catch (error2) {
+        printError("ontology.list", error2, ctx.human);
+      }
+    })
+  );
+  return command;
+}
+
+// src/commands/search.ts
+import { Command as Command9 } from "commander";
+function createSearchCommand() {
+  const command = new Command9("search").description("Search the knowledge base").argument("[query]", "Search query unless using the history subcommand").option("--search-type <type>", "Search type", "INSIGHTS").option("--top-k <count>", "Number of results", "5").option("--datasets <names>", "Comma-separated dataset names to filter by").option("--verbose", "Include request metadata in the response").action(
+    async function(query, options) {
+      const ctx = createContext(this);
+      try {
+        if (!query) {
+          throw configError("query is required unless using `search history`");
+        }
+        const topK = Number.parseInt(options.topK, 10);
+        if (!Number.isFinite(topK) || topK < 1) {
+          throw configError("--top-k must be a positive integer");
+        }
+        const datasets = options.datasets ? options.datasets.split(",").map((value) => value.trim()).filter(Boolean) : [];
+        const response = await ctx.client.search(query, {
+          search_type: options.searchType,
+          top_k: topK,
+          datasets
+        });
+        const data = options.verbose ? {
+          request: {
+            query,
+            search_type: options.searchType,
+            top_k: topK,
+            datasets
+          },
+          response
+        } : response;
+        printSuccess("search", data, ctx);
+      } catch (error2) {
+        printError("search", error2, ctx.human);
+      }
+    }
+  );
+  command.addCommand(
+    new Command9("history").description("Fetch search history").action(async function() {
+      const ctx = createContext(this);
+      try {
+        printSuccess("search.history", await ctx.client.searchHistory(), ctx);
+      } catch (error2) {
+        printError("search.history", error2, ctx.human);
+      }
+    })
+  );
+  return command;
+}
+
+// src/index.ts
+var program = new Command10().name("cognee-admin").description("Cognee knowledge engine management CLI").version("0.2.0").option(
+  "--cognee-url <url>",
+  `Cognee API URL (default: $COGNEE_URL, auth config, or ${DEFAULT_COGNEE_URL})`
+).option("--cognee-jwt <token>", "Cognee JWT for API authentication").option("--human", "Human-readable output instead of JSON").option("--fields <fields>", "Comma-separated list of output fields");
+program.addCommand(createHealthCommand());
+program.addCommand(createLoginCommand());
+program.addCommand(createDatasetCommand());
+program.addCommand(createDataCommand());
+program.addCommand(createCognifyCommand());
+program.addCommand(createSearchCommand());
+program.addCommand(createConfigCommand());
+program.addCommand(createOntologyCommand());
+program.addCommand(createDescribeCommand());
+await program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@doufunao123/cognee-admin",
+  "version": "0.2.0",
+  "description": "Cognee knowledge engine CLI client — search, upload, cognify",
+  "type": "module",
+  "bin": {
+    "cognee-admin": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fran0220/agent-skills",
+    "directory": "cognee-admin/npm"
+  },
+  "author": "doufunao123",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0"
+  }
+}