@chanl-ai/cli 2.0.1

package/dist/commands/health.js

@@ -0,0 +1,55 @@
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import { ChanlSDK } from "@chanl-ai/sdk";
+import { configStore } from "../utils/config-store.js";
+import {
+  printSuccess,
+  printError,
+  printBlank,
+  isJsonOutput,
+  printJson
+} from "../utils/output.js";
+function createHealthCommand() {
+  const health = new Command("health").description("Check API health status").action(handleHealth);
+  return health;
+}
+async function handleHealth() {
+  const baseUrl = configStore.getBaseUrl();
+  const sdk = new ChanlSDK({ baseUrl });
+  const spinner = ora("Checking API health...").start();
+  try {
+    const response = await sdk.health.getHealth();
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("API health check failed", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold("API Health Status:"));
+    console.log(`  Status:   ${response.data.status === "healthy" ? chalk.green("\u2713 healthy") : chalk.red("\u2717 unhealthy")}`);
+    console.log(`  API URL:  ${baseUrl}`);
+    if (response.data.version) {
+      console.log(`  Version:  ${response.data.version}`);
+    }
+    if (response.data.uptime) {
+      console.log(`  Uptime:   ${Math.floor(response.data.uptime / 60)} min`);
+    }
+    printBlank();
+    printSuccess("API is healthy");
+  } catch (error) {
+    spinner.fail("Health check failed");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+export {
+  createHealthCommand
+};
+//# sourceMappingURL=health.js.map

package/dist/commands/health.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/commands/health.ts"],"sourcesContent":["import { Command } from 'commander';\nimport ora from 'ora';\nimport chalk from 'chalk';\nimport { ChanlSDK } from '@chanl-ai/sdk';\nimport { configStore } from '../utils/config-store.js';\nimport {\n  printSuccess,\n  printError,\n  printBlank,\n  isJsonOutput,\n  printJson,\n} from '../utils/output.js';\n\n/**\n * Create the health command\n */\nexport function createHealthCommand(): Command {\n  const health = new Command('health')\n    .description('Check API health status')\n    .action(handleHealth);\n\n  return health;\n}\n\n/**\n * Handle health command\n */\nasync function handleHealth(): Promise<void> {\n  const baseUrl = configStore.getBaseUrl();\n  const sdk = new ChanlSDK({ baseUrl });\n\n  const spinner = ora('Checking API health...').start();\n\n  try {\n    const response = await sdk.health.getHealth();\n\n    spinner.stop();\n\n    if (!response.success || !response.data) {\n      printError('API health check failed', response.message);\n      process.exitCode = 1;\n      return;\n    }\n\n    if (isJsonOutput()) {\n      printJson(response.data);\n      return;\n    }\n\n    printBlank();\n    console.log(chalk.bold('API Health Status:'));\n    console.log(`  Status:   ${response.data.status === 'healthy' ? chalk.green('✓ healthy') : chalk.red('✗ unhealthy')}`);\n    console.log(`  API URL:  ${baseUrl}`);\n    if (response.data.version) {\n      console.log(`  Version:  ${response.data.version}`);\n    }\n    if (response.data.uptime) {\n      console.log(`  Uptime:   ${Math.floor(response.data.uptime / 60)} min`);\n    }\n    printBlank();\n    printSuccess('API is healthy');\n  } catch (error) {\n    spinner.fail('Health check failed');\n    const message = error instanceof Error ? error.message : 'Unknown error';\n    printError('Error', message);\n    process.exitCode = 1;\n  }\n}\n"],"mappings":"AAAA,SAAS,eAAe;AACxB,OAAO,SAAS;AAChB,OAAO,WAAW;AAClB,SAAS,gBAAgB;AACzB,SAAS,mBAAmB;AAC5B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKA,SAAS,sBAA+B;AAC7C,QAAM,SAAS,IAAI,QAAQ,QAAQ,EAChC,YAAY,yBAAyB,EACrC,OAAO,YAAY;AAEtB,SAAO;AACT;AAKA,eAAe,eAA8B;AAC3C,QAAM,UAAU,YAAY,WAAW;AACvC,QAAM,MAAM,IAAI,SAAS,EAAE,QAAQ,CAAC;AAEpC,QAAM,UAAU,IAAI,wBAAwB,EAAE,MAAM;AAEpD,MAAI;AACF,UAAM,WAAW,MAAM,IAAI,OAAO,UAAU;AAE5C,YAAQ,KAAK;AAEb,QAAI,CAAC,SAAS,WAAW,CAAC,SAAS,MAAM;AACvC,iBAAW,2BAA2B,SAAS,OAAO;AACtD,cAAQ,WAAW;AACnB;AAAA,IACF;AAEA,QAAI,aAAa,GAAG;AAClB,gBAAU,SAAS,IAAI;AACvB;AAAA,IACF;AAEA,eAAW;AACX,YAAQ,IAAI,MAAM,KAAK,oBAAoB,CAAC;AAC5C,YAAQ,IAAI,eAAe,SAAS,KAAK,WAAW,YAAY,MAAM,MAAM,gBAAW,IAAI,MAAM,IAAI,kBAAa,CAAC,EAAE;AACrH,YAAQ,IAAI,eAAe,OAAO,EAAE;AACpC,QAAI,SAAS,KAAK,SAAS;AACzB,cAAQ,IAAI,eAAe,SAAS,KAAK,OAAO,EAAE;AAAA,IACpD;AACA,QAAI,SAAS,KAAK,QAAQ;AACxB,cAAQ,IAAI,eAAe,KAAK,MAAM,SAAS,KAAK,SAAS,EAAE,CAAC,MAAM;AAAA,IACxE;AACA,eAAW;AACX,iBAAa,gBAAgB;AAAA,EAC/B,SAAS,OAAO;AACd,YAAQ,KAAK,qBAAqB;AAClC,UAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU;AACzD,eAAW,SAAS,OAAO;AAC3B,YAAQ,WAAW;AAAA,EACrB;AACF;","names":[]}

package/dist/commands/index.d.ts

@@ -0,0 +1,18 @@
+export { createAuthCommand, createLoginCommand, createLogoutCommand } from './auth.js';
+export { createConfigCommand } from './config.js';
+export { createToolsCommand } from './tools.js';
+export { createToolsetsCommand } from './toolsets.js';
+export { createScenariosCommand } from './scenarios.js';
+export { createCallCommand } from './call.js';
+export { createCallsCommand } from './calls.js';
+export { createPersonasCommand } from './personas.js';
+export { createAgentsCommand } from './agents.js';
+export { createHealthCommand } from './health.js';
+export { createMcpCommand } from './mcp.js';
+export { createScorecardsCommand } from './scorecards.js';
+export { createKnowledgeCommand } from './knowledge.js';
+export { createMemoryCommand } from './memory.js';
+export { createChatCommand } from './chat.js';
+export { createPromptsCommand } from './prompts.js';
+export { createWorkspacesCommand } from './workspaces.js';
+import 'commander';

package/dist/commands/index.js

@@ -0,0 +1,39 @@
+import { createAuthCommand, createLoginCommand, createLogoutCommand } from "./auth.js";
+import { createConfigCommand } from "./config.js";
+import { createToolsCommand } from "./tools.js";
+import { createToolsetsCommand } from "./toolsets.js";
+import { createScenariosCommand } from "./scenarios.js";
+import { createCallCommand } from "./call.js";
+import { createCallsCommand } from "./calls.js";
+import { createPersonasCommand } from "./personas.js";
+import { createAgentsCommand } from "./agents.js";
+import { createHealthCommand } from "./health.js";
+import { createMcpCommand } from "./mcp.js";
+import { createScorecardsCommand } from "./scorecards.js";
+import { createKnowledgeCommand } from "./knowledge.js";
+import { createMemoryCommand } from "./memory.js";
+import { createChatCommand } from "./chat.js";
+import { createPromptsCommand } from "./prompts.js";
+import { createWorkspacesCommand } from "./workspaces.js";
+export {
+  createAgentsCommand,
+  createAuthCommand,
+  createCallCommand,
+  createCallsCommand,
+  createChatCommand,
+  createConfigCommand,
+  createHealthCommand,
+  createKnowledgeCommand,
+  createLoginCommand,
+  createLogoutCommand,
+  createMcpCommand,
+  createMemoryCommand,
+  createPersonasCommand,
+  createPromptsCommand,
+  createScenariosCommand,
+  createScorecardsCommand,
+  createToolsCommand,
+  createToolsetsCommand,
+  createWorkspacesCommand
+};
+//# sourceMappingURL=index.js.map

package/dist/commands/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/commands/index.ts"],"sourcesContent":["/**\n * Command exports for the Chanl CLI\n */\n\nexport { createAuthCommand, createLoginCommand, createLogoutCommand } from './auth.js';\nexport { createConfigCommand } from './config.js';\nexport { createToolsCommand } from './tools.js';\nexport { createToolsetsCommand } from './toolsets.js';\nexport { createScenariosCommand } from './scenarios.js';\nexport { createCallCommand } from './call.js';\nexport { createCallsCommand } from './calls.js';\nexport { createPersonasCommand } from './personas.js';\nexport { createAgentsCommand } from './agents.js';\nexport { createHealthCommand } from './health.js';\nexport { createMcpCommand } from './mcp.js';\nexport { createScorecardsCommand } from './scorecards.js';\nexport { createKnowledgeCommand } from './knowledge.js';\nexport { createMemoryCommand } from './memory.js';\nexport { createChatCommand } from './chat.js';\nexport { createPromptsCommand } from './prompts.js';\nexport { createWorkspacesCommand } from './workspaces.js';\n"],"mappings":"AAIA,SAAS,mBAAmB,oBAAoB,2BAA2B;AAC3E,SAAS,2BAA2B;AACpC,SAAS,0BAA0B;AACnC,SAAS,6BAA6B;AACtC,SAAS,8BAA8B;AACvC,SAAS,yBAAyB;AAClC,SAAS,0BAA0B;AACnC,SAAS,6BAA6B;AACtC,SAAS,2BAA2B;AACpC,SAAS,2BAA2B;AACpC,SAAS,wBAAwB;AACjC,SAAS,+BAA+B;AACxC,SAAS,8BAA8B;AACvC,SAAS,2BAA2B;AACpC,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,+BAA+B;","names":[]}

package/dist/commands/knowledge.d.ts

@@ -0,0 +1,8 @@
+import { Command } from 'commander';
+
+/**
+ * Create the knowledge command group
+ */
+declare function createKnowledgeCommand(): Command;
+
+export { createKnowledgeCommand };

package/dist/commands/knowledge.js

@@ -0,0 +1,539 @@
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { ChanlSDK } from "@chanl-ai/sdk";
+import { configStore } from "../utils/config-store.js";
+import {
+  printError,
+  printSuccess,
+  printInfo,
+  printBlank,
+  printSimpleTable,
+  printLabel,
+  isJsonOutput,
+  printJson,
+  formatDate
+} from "../utils/output.js";
+function createKnowledgeCommand() {
+  const knowledge = new Command("kb").alias("knowledge").description("Manage knowledge base entries (RAG)").addHelpText(
+    "after",
+    `
+What is Knowledge Base?
+  The knowledge base stores documents, FAQs, and other content that AI agents
+  can search and retrieve during conversations. Supports text, URLs, and files.
+
+Quick Start:
+  $ chanl kb list                              # List all entries
+  $ chanl kb add --text "FAQ content" --title "FAQ"  # Add text content
+  $ chanl kb add --url https://docs.example.com      # Add from URL
+  $ chanl kb add --file ./docs/guide.pdf             # Upload file
+  $ chanl kb search "how do I reset password"        # Search KB
+
+Workflow:
+  1. Add content via text, URL, or file upload
+  2. Search to verify content is indexed
+  3. Associate with agents for RAG retrieval`
+  );
+  knowledge.command("list").description("List knowledge base entries").option("-s, --search <query>", "Filter by title/content search").option("--source <source>", "Filter by source (text, url, file, manual)").option("--status <status>", "Filter by processing status").option("--folder <folderId>", "Filter by folder ID").option("-l, --limit <number>", "Number of items per page", "20").option("--page <number>", "Page number", "1").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl kb list                              # List all entries
+  $ chanl kb list --source url                 # Only URL-sourced entries
+  $ chanl kb list --status completed           # Only fully processed
+  $ chanl kb list --json                       # Output as JSON`
+  ).action(handleKnowledgeList);
+  knowledge.command("get <id>").description("Get knowledge entry details").option("--chunks", "Include chunk details").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl kb get abc123                        # Get entry details
+  $ chanl kb get abc123 --chunks               # Include chunks
+  $ chanl kb get abc123 --json                 # Output as JSON`
+  ).action(handleKnowledgeGet);
+  knowledge.command("add").description("Add knowledge content (text, URL, or file)").option("-t, --title <title>", "Title for the entry").option("--text <content>", "Direct text content").option("--url <url>", "URL to fetch content from").option("-f, --file <path>", "File to upload (PDF, TXT, HTML, MD)").option("--folder <folderId>", "Folder ID to organize entry").option("--tags <tags>", "Comma-separated tags").option("--category <category>", "Category for organization").option("--crawl-depth <depth>", "URL crawl depth (0-2)", "0").option("--max-pages <pages>", "Max pages to crawl (1-50)", "10").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl kb add --text "Content here" --title "FAQ"
+  $ chanl kb add --url https://docs.example.com --title "Docs"
+  $ chanl kb add --url https://docs.example.com --crawl-depth 1 --max-pages 20
+  $ chanl kb add --file ./guide.pdf --title "User Guide"
+  $ chanl kb add --text "Content" --tags "faq,support" --category "support"`
+  ).action(handleKnowledgeAdd);
+  knowledge.command("update <id>").description("Update a knowledge entry").option("-t, --title <title>", "New title").option("--content <content>", "New content (text entries only)").option("--tags <tags>", "Comma-separated tags").option("--category <category>", "Category").option("--enabled <boolean>", "Enable/disable for search").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl kb update abc123 --title "New Title"
+  $ chanl kb update abc123 --enabled false
+  $ chanl kb update abc123 --tags "updated,important"`
+  ).action(handleKnowledgeUpdate);
+  knowledge.command("delete <id>").description("Delete a knowledge entry").option("-y, --yes", "Skip confirmation prompt").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl kb delete abc123
+  $ chanl kb delete abc123 --yes               # Skip confirmation`
+  ).action(handleKnowledgeDelete);
+  knowledge.command("search <query>").description("Search the knowledge base").option("-m, --mode <mode>", "Search mode: hybrid, vector, text", "hybrid").option("-l, --limit <number>", "Max results", "10").option("--min-score <score>", "Minimum similarity score (0-1)").addHelpText(
+    "after",
+    `
+Search Modes:
+  hybrid  - Combined vector + text search (default, best results)
+  vector  - Semantic similarity search
+  text    - Full-text keyword search
+
+Examples:
+  $ chanl kb search "how to reset password"
+  $ chanl kb search "API authentication" --mode vector
+  $ chanl kb search "billing" --limit 5 --min-score 0.7`
+  ).action(handleKnowledgeSearch);
+  knowledge.command("status <taskId>").description("Check processing status of async upload").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl kb status abc123                     # Check task status`
+  ).action(handleKnowledgeStatus);
+  return knowledge;
+}
+async function handleKnowledgeList(options) {
+  const apiKey = configStore.getApiKey();
+  if (!apiKey) {
+    printError("Not logged in", "Run: chanl auth login");
+    process.exitCode = 1;
+    return;
+  }
+  const sdk = new ChanlSDK({
+    baseUrl: configStore.getBaseUrl(),
+    apiKey
+  });
+  const spinner = ora("Fetching knowledge entries...").start();
+  try {
+    const filters = {
+      search: options.search,
+      source: options.source,
+      processingStatus: options.status,
+      folderId: options.folder,
+      limit: parseInt(options.limit),
+      page: parseInt(options.page)
+    };
+    const response = await sdk.knowledge.list(filters);
+    spinner.stop();
+    if (!response.success) {
+      printError("Failed to list knowledge entries", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const responseData = response.data;
+    const entries = responseData?.items || [];
+    const total = responseData?.total ?? entries.length;
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    if (entries.length === 0) {
+      printInfo("No knowledge entries found");
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold(`Knowledge Base (${total} entries)`));
+    printBlank();
+    printSimpleTable(
+      ["ID", "Title", "Source", "Status", "Chunks", "Created"],
+      entries.map((entry) => [
+        entry.id.slice(0, 8),
+        (entry.title || "Untitled").slice(0, 40),
+        entry.source,
+        formatStatus(entry.processingStatus),
+        String(entry.chunkCount || "-"),
+        formatDate(entry.createdAt)
+      ])
+    );
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to list knowledge entries");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleKnowledgeGet(id, options) {
+  const apiKey = configStore.getApiKey();
+  if (!apiKey) {
+    printError("Not logged in", "Run: chanl auth login");
+    process.exitCode = 1;
+    return;
+  }
+  const sdk = new ChanlSDK({
+    baseUrl: configStore.getBaseUrl(),
+    apiKey
+  });
+  const spinner = ora("Fetching knowledge entry...").start();
+  try {
+    const response = await sdk.knowledge.get(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Knowledge entry not found", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const responseData = response.data;
+    const entry = "knowledge" in responseData && responseData.knowledge ? responseData.knowledge : responseData;
+    if (isJsonOutput()) {
+      printJson(entry);
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold("Knowledge Entry Details"));
+    printBlank();
+    printLabel("ID", entry.id);
+    printLabel("Title", entry.title);
+    printLabel("Source", entry.source);
+    printLabel("Status", formatStatus(entry.processingStatus));
+    if (entry.chunkCount) printLabel("Chunks", entry.chunkCount.toString());
+    if (entry.tokenCount) printLabel("Tokens", entry.tokenCount.toString());
+    if (entry.folderId) printLabel("Folder", entry.folderId);
+    if (entry.metadata?.category) printLabel("Category", entry.metadata.category);
+    if (entry.metadata?.tags?.length) {
+      printLabel("Tags", entry.metadata.tags.join(", "));
+    }
+    if (entry.createdAt) printLabel("Created", formatDate(entry.createdAt));
+    if (entry.updatedAt) printLabel("Updated", formatDate(entry.updatedAt));
+    if (entry.content) {
+      printBlank();
+      console.log(chalk.bold("Content Preview:"));
+      console.log(chalk.dim(entry.content.slice(0, 500) + (entry.content.length > 500 ? "..." : "")));
+    }
+    if (options.chunks) {
+      const chunksResponse = await sdk.knowledge.getChunks(id);
+      if (chunksResponse.success && chunksResponse.data) {
+        printBlank();
+        console.log(chalk.bold(`Chunks (${chunksResponse.data.length}):`));
+        chunksResponse.data.slice(0, 5).forEach((chunk, i) => {
+          console.log(chalk.dim(`  [${i + 1}] ${chunk.content.slice(0, 100)}...`));
+        });
+        if (chunksResponse.data.length > 5) {
+          console.log(chalk.dim(`  ... and ${chunksResponse.data.length - 5} more`));
+        }
+      }
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to get knowledge entry");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleKnowledgeAdd(options) {
+  const apiKey = configStore.getApiKey();
+  if (!apiKey) {
+    printError("Not logged in", "Run: chanl auth login");
+    process.exitCode = 1;
+    return;
+  }
+  const sources = [options.text, options.url, options.file].filter(Boolean);
+  if (sources.length === 0) {
+    printError("Missing content", "Provide --text, --url, or --file");
+    process.exitCode = 1;
+    return;
+  }
+  if (sources.length > 1) {
+    printError("Too many sources", "Provide only one of --text, --url, or --file");
+    process.exitCode = 1;
+    return;
+  }
+  const sdk = new ChanlSDK({
+    baseUrl: configStore.getBaseUrl(),
+    apiKey
+  });
+  const spinner = ora("Adding knowledge entry...").start();
+  try {
+    let response;
+    if (options.file) {
+      const filePath = resolve(options.file);
+      if (!existsSync(filePath)) {
+        spinner.fail("File not found");
+        printError("File not found", filePath);
+        process.exitCode = 1;
+        return;
+      }
+      const fileBuffer = readFileSync(filePath);
+      const filename = options.file.split("/").pop() || "document";
+      response = await sdk.knowledge.createFromFile(fileBuffer, filename, {
+        title: options.title || filename,
+        folderId: options.folder,
+        metadata: {
+          category: options.category,
+          tags: options.tags?.split(",").map((t) => t.trim())
+        }
+      });
+    } else {
+      const createData = {
+        title: options.title || (options.url ? "URL Import" : "Text Entry"),
+        source: options.url ? "url" : "text",
+        content: options.text,
+        url: options.url,
+        folderId: options.folder,
+        metadata: {
+          category: options.category,
+          tags: options.tags?.split(",").map((t) => t.trim())
+        }
+      };
+      if (options.url) {
+        createData.crawlOptions = {
+          depth: parseInt(options.crawlDepth || "0"),
+          maxPages: parseInt(options.maxPages || "10"),
+          sameDomainOnly: true
+        };
+      }
+      response = await sdk.knowledge.create(createData);
+    }
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to add knowledge entry", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const entry = response.data;
+    if (isJsonOutput()) {
+      printJson(entry);
+      return;
+    }
+    printBlank();
+    if (entry.taskId) {
+      printSuccess(`Knowledge entry queued for processing`);
+      printLabel("ID", entry.id);
+      printLabel("Task ID", entry.taskId);
+      printLabel("Status", formatStatus(entry.processingStatus));
+      printInfo(`Track progress: chanl kb status ${entry.taskId}`);
+    } else {
+      printSuccess(`Knowledge entry created`);
+      printLabel("ID", entry.id);
+      printLabel("Title", entry.title);
+      printLabel("Status", formatStatus(entry.processingStatus));
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to add knowledge entry");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleKnowledgeUpdate(id, options) {
+  const apiKey = configStore.getApiKey();
+  if (!apiKey) {
+    printError("Not logged in", "Run: chanl auth login");
+    process.exitCode = 1;
+    return;
+  }
+  const sdk = new ChanlSDK({
+    baseUrl: configStore.getBaseUrl(),
+    apiKey
+  });
+  const spinner = ora("Updating knowledge entry...").start();
+  try {
+    const updateData = {};
+    if (options.title) updateData.title = options.title;
+    if (options.content) updateData.content = options.content;
+    if (options.enabled !== void 0) {
+      updateData.isEnabled = options.enabled === "true";
+    }
+    if (options.tags || options.category) {
+      updateData.metadata = {
+        ...options.category && { category: options.category },
+        ...options.tags && { tags: options.tags.split(",").map((t) => t.trim()) }
+      };
+    }
+    const response = await sdk.knowledge.update(id, updateData);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to update knowledge entry", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const responseData = response.data;
+    const entry = "knowledge" in responseData && responseData.knowledge ? responseData.knowledge : responseData;
+    if (isJsonOutput()) {
+      printJson(entry);
+      return;
+    }
+    printBlank();
+    printSuccess("Knowledge entry updated");
+    printLabel("ID", entry.id);
+    printLabel("Title", entry.title);
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to update knowledge entry");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleKnowledgeDelete(id, options) {
+  const apiKey = configStore.getApiKey();
+  if (!apiKey) {
+    printError("Not logged in", "Run: chanl auth login");
+    process.exitCode = 1;
+    return;
+  }
+  if (!options.yes) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve2) => {
+      rl.question(chalk.yellow(`Delete knowledge entry ${id}? [y/N] `), resolve2);
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y") {
+      printInfo("Cancelled");
+      return;
+    }
+  }
+  const sdk = new ChanlSDK({
+    baseUrl: configStore.getBaseUrl(),
+    apiKey
+  });
+  const spinner = ora("Deleting knowledge entry...").start();
+  try {
+    await sdk.knowledge.delete(id);
+    spinner.stop();
+    if (isJsonOutput()) {
+      printJson({ deleted: true, id });
+      return;
+    }
+    printBlank();
+    printSuccess(`Knowledge entry deleted: ${id}`);
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to delete knowledge entry");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleKnowledgeSearch(query, options) {
+  const apiKey = configStore.getApiKey();
+  if (!apiKey) {
+    printError("Not logged in", "Run: chanl auth login");
+    process.exitCode = 1;
+    return;
+  }
+  const sdk = new ChanlSDK({
+    baseUrl: configStore.getBaseUrl(),
+    apiKey
+  });
+  const spinner = ora("Searching knowledge base...").start();
+  try {
+    const searchData = {
+      query,
+      mode: options.mode || "hybrid",
+      limit: parseInt(options.limit || "10"),
+      minScore: options.minScore ? parseFloat(options.minScore) : void 0
+    };
+    const response = await sdk.knowledge.search(searchData);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Search failed", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const results = response.data.results || [];
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold(`Search Results (${results.length} matches)`));
+    console.log(chalk.dim(`Query: "${query}" | Mode: ${options.mode || "hybrid"}`));
+    printBlank();
+    if (results.length === 0) {
+      printInfo("No matching results found");
+      return;
+    }
+    results.forEach((result, index) => {
+      console.log(
+        chalk.cyan(`[${index + 1}]`) + ` ${chalk.bold(result.title || "Untitled")} ` + chalk.dim(`(score: ${result.score.toFixed(3)})`)
+      );
+      console.log(chalk.dim(`    ${result.content.slice(0, 150)}...`));
+      console.log(chalk.dim(`    ID: ${result.id || result.knowledgeId}`));
+      printBlank();
+    });
+  } catch (error) {
+    spinner.fail("Search failed");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleKnowledgeStatus(taskId) {
+  const apiKey = configStore.getApiKey();
+  if (!apiKey) {
+    printError("Not logged in", "Run: chanl auth login");
+    process.exitCode = 1;
+    return;
+  }
+  const sdk = new ChanlSDK({
+    baseUrl: configStore.getBaseUrl(),
+    apiKey
+  });
+  const spinner = ora("Checking task status...").start();
+  try {
+    const response = await sdk.knowledge.getTaskStatus(taskId);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Task not found", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const task = response.data;
+    if (isJsonOutput()) {
+      printJson(task);
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold("Processing Task Status"));
+    printBlank();
+    printLabel("Task ID", task.id);
+    printLabel("Status", formatStatus(task.status));
+    printLabel("Progress", `${task.progress}%`);
+    if (task.currentStep) printLabel("Current Step", task.currentStep);
+    if (task.documentId) printLabel("Document ID", task.documentId);
+    if (task.error) printLabel("Error", chalk.red(task.error));
+    if (task.result) {
+      printLabel("Chunks", task.result.chunkCount.toString());
+      printLabel("Words", task.result.wordCount.toString());
+      printLabel("Processing Time", `${task.result.processingTimeMs}ms`);
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to get task status");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+function formatStatus(status) {
+  switch (status) {
+    case "completed":
+      return chalk.green("completed");
+    case "processing":
+      return chalk.yellow("processing");
+    case "pending":
+      return chalk.blue("pending");
+    case "failed":
+      return chalk.red("failed");
+    default:
+      return chalk.dim(status || "unknown");
+  }
+}
+export {
+  createKnowledgeCommand
+};
+//# sourceMappingURL=knowledge.js.map