@doufunao123/ai-search 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # @doufunao123/ai-search
 
-AI-powered web search CLI (npm package). Uses AI models with native web search capabilities via the xiaomao proxy.
+Gateway client for AI Search Gateway. The npm CLI is a thin HTTP client that talks to `search.xiaomao.chat` instead of calling model APIs directly.
 
 ## Install
 
@@ -11,43 +11,68 @@ npm install -g @doufunao123/ai-search
 ## Setup
 
 ```bash
-ai-search config set api_key your_api_key
-# Or
-export AI_SEARCH_KEY=your_api_key
+ai-search auth set your_gateway_token
+
+# Or use environment variables
+export AI_SEARCH_TOKEN=your_gateway_token
+export AI_SEARCH_GATEWAY_URL=https://search.xiaomao.chat
 ```
 
 ## Usage
 
 ```bash
-# Simple search
+# Default fast search
 ai-search "latest AI news"
 
-# Choose model
-ai-search "query" --model grok-4.1-fast
+# Deep multi-source search
+ai-search "compare latest AI browser agents" --mode deep
 
-# Complex search with query splitting
-ai-search "comprehensive analysis of X" --split 3
+# Answer mode
+ai-search "what changed in Bun this month" --mode answer
 
-# JSON output (default in non-TTY)
-ai-search "query" --json
+# Choose model and query splitting
+ai-search "comprehensive analysis of X" --model grok-4.1-fast --split 3 --num 5
 
-# Human-readable output
-ai-search "query" --human
+# stdin JSON input
+printf '%s\n' '{"query":"latest AI infra news","mode":"deep","num":5}' | ai-search search --stdin
 
-# List models
+# List gateway metadata
 ai-search models
+ai-search providers
+ai-search providers health
+ai-search health
 
-# Show config
+# Config and auth
+ai-search auth status
+ai-search config set gateway_url https://search.xiaomao.chat
 ai-search config show
 ```
 
 ## Configuration
 
-Config file: `~/.config/ai-search/config.json`
+Config file: `~/.config/ai-search/auth.json`
+
+Saved format:
+
+```json
+{
+  "token": "asg_...",
+  "gateway_url": "https://search.xiaomao.chat"
+}
+```
+
+Environment variables:
+- `AI_SEARCH_TOKEN` — gateway token
+- `AI_SEARCH_GATEWAY_URL` — gateway URL
+
+Priority order:
+1. CLI flags (`--gateway-url`, `--token`)
+2. Environment variables
+3. `~/.config/ai-search/auth.json`
+4. Default gateway URL `https://search.xiaomao.chat`
 
-Environment variables (override config):
-- `AI_SEARCH_KEY` — API key
-- `AI_SEARCH_URL` — API base URL (default: `https://grok.xiaomao.chat`)
-- `AI_SEARCH_MODEL` — Default search model (default: `grok-4.1-expert`)
+## Search Modes
 
-Shares credentials with the Rust CLI (`~/.config/ai-search/config.toml`).
+- `fast` — Grok only, default mode
+- `deep` — Grok + Exa + Tavily in parallel
+- `answer` — Tavily answer mode with AI summary

package/dist/index.js

@@ -1,202 +1,248 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { existsSync as existsSync2, unlinkSync } from "fs";
 import { Command } from "commander";
 
+// src/errors.ts
+var GatewayError = class extends Error {
+  code;
+  exitCode;
+  suggestion;
+  constructor(message, options) {
+    super(message);
+    this.name = "GatewayError";
+    this.code = options.code;
+    this.exitCode = options.exitCode ?? 1;
+    this.suggestion = options.suggestion;
+  }
+};
+function inputError(message, suggestion) {
+  return new GatewayError(message, {
+    code: "INPUT_ERROR",
+    exitCode: 1,
+    suggestion
+  });
+}
+function configError(message, suggestion) {
+  return new GatewayError(message, {
+    code: "CONFIG_ERROR",
+    exitCode: 1,
+    suggestion: suggestion ?? "Run ai-search auth set <token> to configure credentials"
+  });
+}
+function notFoundError(message) {
+  return new GatewayError(message, {
+    code: "NOT_FOUND",
+    exitCode: 1
+  });
+}
+function apiError(message, suggestion) {
+  return new GatewayError(message, {
+    code: "GATEWAY_API_ERROR",
+    exitCode: 3,
+    suggestion: suggestion ?? "Check if the gateway is running: ai-search health"
+  });
+}
+function httpClientError(message, suggestion) {
+  return new GatewayError(message, {
+    code: "HTTP_CLIENT_ERROR",
+    exitCode: 3,
+    suggestion: suggestion ?? "Check network connectivity to the gateway"
+  });
+}
+function internalError(message) {
+  return new GatewayError(message, {
+    code: "INTERNAL_ERROR",
+    exitCode: 2
+  });
+}
+function normalizeError(error2) {
+  if (error2 instanceof GatewayError) {
+    return error2;
+  }
+  if (error2 instanceof Error) {
+    return internalError(error2.message);
+  }
+  return internalError(String(error2));
+}
+
+// src/client.ts
+var GatewayClient = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  async search(query, options = {}) {
+    const payload = await this.post("/api/search", {
+      query,
+      mode: options.mode ?? "fast",
+      ...options.model ? { model: options.model } : {},
+      ...options.split !== void 0 ? { split: options.split } : {},
+      ...options.num !== void 0 ? { num: options.num } : {}
+    });
+    return payload;
+  }
+  async models() {
+    const payload = await this.get("/api/models");
+    return extractArray(payload, ["models"]);
+  }
+  async providers() {
+    const payload = await this.get("/api/providers");
+    return extractArray(payload, ["providers"]);
+  }
+  async providersHealth() {
+    const payload = await this.get("/api/providers/health");
+    return extractArray(payload, ["providers", "health"]);
+  }
+  async health() {
+    const payload = await this.get("/health");
+    return isRecord(payload) && payload.status === "ok";
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, { body });
+  }
+  async request(method, path, options = {}) {
+    const url = new URL(path, ensureTrailingSlash(this.baseUrl));
+    const headers = new Headers(options.headers);
+    if (this.token) {
+      headers.set("authorization", `Bearer ${this.token}`);
+    }
+    let body;
+    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)}`);
+    }
+    if (isEnvelope(payload)) {
+      if (!payload.ok) {
+        const message = typeof payload.error === "object" && payload.error !== null ? JSON.stringify(payload.error) : String(payload.error);
+        throw apiError(message);
+      }
+      return payload.data;
+    }
+    return payload;
+  }
+};
+function extractArray(payload, keys) {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+  if (isRecord(payload)) {
+    for (const key of keys) {
+      const value = payload[key];
+      if (Array.isArray(value)) {
+        return value;
+      }
+    }
+    const arrayValue = Object.values(payload).find(Array.isArray);
+    if (Array.isArray(arrayValue)) {
+      return arrayValue;
+    }
+  }
+  throw apiError(`Unexpected response shape for ${keys.join("/")}`);
+}
+function isEnvelope(value) {
+  return isRecord(value) && "ok" in value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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 { dirname, join } from "path";
+
 // src/meta.ts
-var CLI_VERSION = "0.1.0";
-var DEFAULT_API_URL = "https://grok.xiaomao.chat";
-var DEFAULT_SEARCH_MODEL = "grok-4.1-expert";
-var DEFAULT_ANALYSIS_MODEL = "grok-4.1-fast";
+var CLI_NAME = "ai-search";
+var CLI_VERSION = "0.2.0";
+var DEFAULT_GATEWAY_URL = "https://search.xiaomao.chat";
+var SEARCH_MODES = ["fast", "deep", "answer"];
 var SEARCH_MODELS = [
-  "grok-4.1-expert",
   "grok-4.1-fast",
+  "grok-4.1-expert",
   "grok-4.20-beta",
   "grok-4",
   "grok-4-thinking"
 ];
 
 // src/config.ts
-import { existsSync, readFileSync, mkdirSync, writeFileSync, chmodSync } from "fs";
-import { homedir } from "os";
-import { join, dirname } from "path";
 function configDir() {
-  return join(homedir(), ".config", "ai-search");
+  const home = process.env.HOME;
+  if (!home) {
+    throw configError("HOME environment variable is not set");
+  }
+  return join(home, ".config", "ai-search");
 }
 function configPath() {
-  return join(configDir(), "config.json");
+  return join(configDir(), "auth.json");
 }
-function loadConfig() {
-  const defaults = {
-    api_url: DEFAULT_API_URL,
-    api_key: "",
-    search_model: DEFAULT_SEARCH_MODEL,
-    analysis_model: DEFAULT_ANALYSIS_MODEL,
-    max_split: 1,
-    timeout_ms: 12e4
-  };
+function loadAuthConfig() {
   const path = configPath();
-  if (existsSync(path)) {
-    try {
-      const content = readFileSync(path, "utf8");
-      const parsed = JSON.parse(content);
-      Object.assign(defaults, parsed);
-    } catch {
-    }
+  if (!existsSync(path)) {
+    return {};
   }
-  if (!defaults.api_key) {
-    const tomlPath = join(configDir(), "config.toml");
-    if (existsSync(tomlPath)) {
-      try {
-        const toml = readFileSync(tomlPath, "utf8");
-        const keyMatch = toml.match(/^api_key\s*=\s*"([^"]*)"/m);
-        if (keyMatch?.[1]) defaults.api_key = keyMatch[1];
-      } catch {
-      }
-    }
+  const content = readFileSync(path, "utf8");
+  if (!content.trim()) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(content);
+    return { token: parsed.token, gateway_url: parsed.gateway_url };
+  } catch (error2) {
+    throw configError(
+      `Failed to parse auth config at ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
   }
-  if (process.env.AI_SEARCH_URL) defaults.api_url = process.env.AI_SEARCH_URL;
-  if (process.env.AI_SEARCH_KEY) defaults.api_key = process.env.AI_SEARCH_KEY;
-  if (process.env.AI_SEARCH_MODEL) defaults.search_model = process.env.AI_SEARCH_MODEL;
-  if (process.env.AI_SEARCH_ANALYSIS_MODEL) defaults.analysis_model = process.env.AI_SEARCH_ANALYSIS_MODEL;
-  return defaults;
 }
-function saveConfig(config) {
+function saveAuthConfig(config) {
   const path = configPath();
   mkdirSync(dirname(path), { recursive: true });
-  let existing = {};
-  if (existsSync(path)) {
-    try {
-      existing = JSON.parse(readFileSync(path, "utf8"));
-    } catch {
-    }
-  }
-  const merged = { ...existing, ...config };
-  writeFileSync(path, JSON.stringify(merged, null, 2) + "\n", { mode: 384 });
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
   chmodSync(path, 384);
 }
-
-// src/client.ts
-var THINKING_RE = /<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/g;
-var SYSTEM_PROMPT = `You are a real-time web search assistant with direct access to the internet. When the user asks a question:
-
-1. Search the web for the most current, accurate information available
-2. Synthesize results into a clear, well-structured answer
-3. Always include sources with URLs and dates when available
-4. Be concise but comprehensive \u2014 cover key facts without unnecessary padding
-5. If the query is in Chinese, respond entirely in Chinese; otherwise match the query language
-6. When results conflict, note the discrepancy and indicate which sources are more authoritative
-7. Format sources as a numbered list at the end of your response`;
-function stripThinking(text) {
-  return text.replace(THINKING_RE, "").trim();
+function resolveGatewayUrl(overrides) {
+  return overrides?.gatewayUrl ?? process.env.AI_SEARCH_GATEWAY_URL ?? loadAuthConfig().gateway_url ?? DEFAULT_GATEWAY_URL;
+}
+function resolveToken(overrides) {
+  return overrides?.token ?? process.env.AI_SEARCH_TOKEN ?? loadAuthConfig().token;
 }
-var AIClient = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async chat(messages, model) {
-    const url = `${this.config.api_url.replace(/\/+$/, "")}/v1/chat/completions`;
-    const resp = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.api_key}`
-      },
-      body: JSON.stringify({ model, messages, stream: false }),
-      signal: AbortSignal.timeout(this.config.timeout_ms)
-    });
-    if (!resp.ok) {
-      const body = await resp.text().catch(() => "");
-      throw new Error(`AI API HTTP ${resp.status}: ${body.slice(0, 500)}`);
-    }
-    const data = await resp.json();
-    const content = stripThinking(data.choices?.[0]?.message?.content ?? "");
-    const tokens = data.usage?.total_tokens ?? 0;
-    return { content, tokens };
-  }
-  async search(query, model, split = 1) {
-    if (split <= 1) {
-      const { content, tokens } = await this.chat(
-        [
-          { role: "system", content: SYSTEM_PROMPT },
-          { role: "user", content: query }
-        ],
-        model
-      );
-      return { query, model, content, tokens };
-    }
-    const subQueries = await this.splitQuery(query, split);
-    const subResults = await Promise.all(
-      subQueries.map(async (sq) => {
-        const { content, tokens } = await this.chat(
-          [
-            { role: "system", content: SYSTEM_PROMPT },
-            { role: "user", content: sq }
-          ],
-          model
-        );
-        return { sub_query: sq, content, tokens };
-      })
-    );
-    const totalSubTokens = subResults.reduce((sum, r) => sum + r.tokens, 0);
-    const { content: merged, tokens: mergeTokens } = await this.mergeResults(query, subResults);
-    return {
-      query,
-      model,
-      content: merged,
-      tokens: totalSubTokens + mergeTokens,
-      sub_results: subResults
-    };
-  }
-  async splitQuery(query, maxSplit) {
-    const { content } = await this.chat(
-      [
-        {
-          role: "system",
-          content: "You are a query analysis assistant. You split complex questions into independent sub-queries for parallel web search. Always respond with a valid JSON array of strings."
-        },
-        {
-          role: "user",
-          content: `Split the following complex search query into ${maxSplit} or fewer independent sub-questions that can be searched separately. Return ONLY a JSON array of strings, nothing else.
-
-Query: ${query}`
-        }
-      ],
-      this.config.analysis_model
-    );
-    try {
-      let jsonStr = content.trim();
-      if (jsonStr.startsWith("```")) {
-        jsonStr = jsonStr.split("\n").slice(1).filter((l) => !l.startsWith("```")).join("\n");
-      }
-      const parsed = JSON.parse(jsonStr);
-      if (Array.isArray(parsed) && parsed.length > 0) return parsed;
-    } catch {
-    }
-    return [query];
-  }
-  async mergeResults(originalQuery, subResults) {
-    const context = subResults.map((r, i) => `--- Sub-query ${i + 1}: ${r.sub_query} ---
-${r.content}`).join("\n\n");
-    return this.chat(
-      [
-        {
-          role: "system",
-          content: "You are a research synthesis assistant. Merge multiple search results into a single coherent answer. Keep all sources and citations. Match the language of the original query."
-        },
-        {
-          role: "user",
-          content: `Based on the following search results for sub-queries, provide a comprehensive answer to the original question. Synthesize the information, remove duplicates, and present a coherent response with sources.
-
-Original question: ${originalQuery}
-
-${context}`
-        }
-      ],
-      this.config.analysis_model
-    );
-  }
-};
 
 // src/output.ts
 function success(command, data) {
@@ -228,75 +274,236 @@ function output(result, human = false) {
 }
 
 // src/index.ts
-var program = new Command().name("ai-search").description("AI-powered web search CLI").version(CLI_VERSION);
-program.argument("[query...]", "Search query").option("-m, --model <model>", "Model to use").option("--split <n>", "Max sub-queries for query splitting", "1").option("--json", "Force JSON output").option("--human", "Human-readable output").action(async (queryParts, opts) => {
-  const query = queryParts.join(" ");
-  if (!query) {
+var program = new Command().name(CLI_NAME).description("AI Search Gateway CLI client").version(CLI_VERSION).option(
+  "--gateway-url <url>",
+  `Gateway URL (default: $AI_SEARCH_GATEWAY_URL, auth config, or ${DEFAULT_GATEWAY_URL})`
+).option("--token <token>", "Gateway token for authentication").option("--human", "Human-readable output instead of JSON");
+program.argument("[query...]", "Search query").option("--mode <mode>", `Search mode (${SEARCH_MODES.join(", ")}; default: fast)`).option("-m, --model <model>", "Model to use").option("--split <n>", "Max sub-queries for query splitting").option("--num <n>", "Max search results to request").action(async function(queryParts) {
+  if (queryParts.length === 0) {
     program.help();
     return;
   }
-  await doSearch(query, opts);
+  await runSearchCommand(queryParts, this, "search");
 });
-program.command("search <query...>").description("Search the web").option("-m, --model <model>", "Model to use").option("--split <n>", "Max sub-queries for query splitting", "1").option("--json", "Force JSON output").option("--human", "Human-readable output").option("--stdin", "Read query from stdin JSON").action(async (queryParts, opts) => {
-  let query;
-  if (opts.stdin) {
-    const chunks = [];
-    for await (const chunk of process.stdin) chunks.push(chunk);
-    const input = JSON.parse(Buffer.concat(chunks).toString());
-    query = input.query ?? "";
-    if (input.model) opts.model = input.model;
-    if (input.split) opts.split = String(input.split);
-  } else {
-    query = queryParts.join(" ");
+program.command("search [query...]").description("Search the web through the gateway").option("--mode <mode>", `Search mode (${SEARCH_MODES.join(", ")}; default: fast)`).option("-m, --model <model>", "Model to use").option("--split <n>", "Max sub-queries for query splitting").option("--num <n>", "Max search results to request").option("--stdin", "Read query from stdin JSON").action(async function(queryParts) {
+  await runSearchCommand(queryParts, this, "search");
+});
+program.command("models").description("List available gateway models").action(async function() {
+  const globals = this.optsWithGlobals();
+  try {
+    const client = createClient(globals);
+    const models = await client.models();
+    output(success("models", { models }), Boolean(globals.human));
+  } catch (err) {
+    printError("models", err, Boolean(globals.human));
   }
-  await doSearch(query, opts);
 });
-program.command("models").description("List available search models").action(() => {
-  output(success("models", { models: SEARCH_MODELS }));
+program.command("providers").description("List gateway search providers").action(async function() {
+  const globals = this.optsWithGlobals();
+  try {
+    const client = createClient(globals);
+    const providers = await client.providers();
+    output(success("providers", { providers }), Boolean(globals.human));
+  } catch (err) {
+    printError("providers", err, Boolean(globals.human));
+  }
+}).addCommand(
+  new Command("health").description("Check provider health").action(async function() {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createClient(globals);
+      const providers = await client.providersHealth();
+      output(success("providers.health", { providers }), Boolean(globals.human));
+    } catch (err) {
+      printError("providers.health", err, Boolean(globals.human));
+    }
+  })
+);
+program.command("health").description("Check gateway health").action(async function() {
+  const globals = this.optsWithGlobals();
+  try {
+    const client = createClient(globals, false);
+    const healthy = await client.health();
+    output(success("health", { status: healthy ? "ok" : "unexpected" }), Boolean(globals.human));
+  } catch (err) {
+    printError("health", err, Boolean(globals.human));
+  }
 });
+program.command("auth").description("Credential management").addCommand(
+  new Command("set").description("Save token and gateway URL locally").argument("<token>", "Gateway token").action(function(token) {
+    const globals = this.optsWithGlobals();
+    try {
+      const current = loadAuthConfig();
+      const gatewayUrl = resolveGatewayUrl({ gatewayUrl: globals.gatewayUrl });
+      saveAuthConfig({ ...current, token, gateway_url: gatewayUrl });
+      output(success("auth.set", { saved: true, gateway_url: gatewayUrl }), Boolean(globals.human));
+    } catch (err) {
+      printError("auth.set", err, Boolean(globals.human));
+    }
+  })
+).addCommand(
+  new Command("status").description("Show saved authentication status").action(function() {
+    const globals = this.optsWithGlobals();
+    try {
+      const config = loadAuthConfig();
+      output(
+        success("auth.status", {
+          config_path: configPath(),
+          has_token: Boolean(config.token),
+          token_preview: config.token ? mask(config.token) : null,
+          gateway_url: config.gateway_url ?? null
+        }),
+        Boolean(globals.human)
+      );
+    } catch (err) {
+      printError("auth.status", err, Boolean(globals.human));
+    }
+  })
+).addCommand(
+  new Command("clear").description("Remove saved credentials").action(function() {
+    const globals = this.optsWithGlobals();
+    try {
+      const path = configPath();
+      if (existsSync2(path)) {
+        unlinkSync(path);
+      }
+      output(success("auth.clear", { cleared: true }), Boolean(globals.human));
+    } catch (err) {
+      printError("auth.clear", err, Boolean(globals.human));
+    }
+  })
+);
 program.command("config").description("Manage configuration").addCommand(
-  new Command("set").description("Set a config value").argument("<key>", "Config key (api_url, api_key, search_model, analysis_model)").argument("<value>", "Config value").action((key, value) => {
-    saveConfig({ [key]: value });
-    output(success("config.set", { key, value: key === "api_key" ? "***" : value }));
+  new Command("set").description("Set a config value").argument("<key>", "Config key (gateway_url)").argument("<value>", "Config value").action(function(key, value) {
+    const globals = this.optsWithGlobals();
+    try {
+      if (key !== "gateway_url") {
+        throw inputError(`Unsupported config key: ${key}`);
+      }
+      const current = loadAuthConfig();
+      saveAuthConfig({ ...current, gateway_url: value });
+      output(success("config.set", { key, value }), Boolean(globals.human));
+    } catch (err) {
+      printError("config.set", err, Boolean(globals.human));
+    }
   })
 ).addCommand(
-  new Command("show").description("Show current configuration").action(() => {
-    const config = loadConfig();
-    output(
-      success("config.show", {
-        ...config,
-        api_key: config.api_key ? `${config.api_key.slice(0, 8)}...` : "(not set)"
-      })
-    );
+  new Command("show").description("Show current configuration").action(function() {
+    const globals = this.optsWithGlobals();
+    try {
+      const token = resolveToken({ token: globals.token });
+      output(
+        success("config.show", {
+          config_path: configPath(),
+          gateway_url: resolveGatewayUrl({ gatewayUrl: globals.gatewayUrl }),
+          has_token: Boolean(token),
+          token_preview: token ? mask(token) : null,
+          search_modes: SEARCH_MODES,
+          search_models: SEARCH_MODELS
+        }),
+        Boolean(globals.human)
+      );
+    } catch (err) {
+      printError("config.show", err, Boolean(globals.human));
+    }
   })
 );
-async function doSearch(query, opts) {
-  const config = loadConfig();
-  if (!config.api_key) {
-    output(error("search", "NO_API_KEY", "API key not configured", "Run: ai-search config set api_key <key>  OR  export AI_SEARCH_KEY=<key>"));
-    process.exit(1);
-  }
-  const client = new AIClient(config);
-  const model = opts.model ?? config.search_model;
-  const split = parseInt(opts.split ?? "1", 10);
+await program.parseAsync(process.argv);
+async function runSearchCommand(queryParts, command, commandName) {
+  const options = command.optsWithGlobals();
   try {
-    const result = await client.search(query, model, split);
-    const isHuman = opts.human || process.stdout.isTTY && !opts.json;
-    if (isHuman) {
-      process.stderr.write(`
-\u{1F50D} [${result.model}] Search: ${result.query}
-
-`);
-      process.stdout.write(result.content + "\n");
-      process.stderr.write(`
-\u{1F4CA} Tokens: ${result.tokens}
-`);
-    } else {
-      output(success("search", result));
+    const request = await resolveSearchRequest(queryParts, options);
+    const client = createClient(options);
+    const result = await client.search(request.query, {
+      mode: request.mode,
+      model: request.model,
+      split: request.split,
+      num: request.num
+    });
+    output(success(commandName, result), Boolean(options.human));
+  } catch (err) {
+    printError(commandName, err, Boolean(options.human));
+  }
+}
+function createClient(globals, requireAuth = true) {
+  const gatewayUrl = resolveGatewayUrl({ gatewayUrl: globals.gatewayUrl });
+  const token = resolveToken({ token: globals.token });
+  if (requireAuth && !token) {
+    throw configError(
+      "Authentication required. Use --token, set AI_SEARCH_TOKEN, or run ai-search auth set <token>.",
+      "ai-search auth set <token>"
+    );
+  }
+  return new GatewayClient(gatewayUrl, token);
+}
+async function resolveSearchRequest(queryParts, options) {
+  const input = options.stdin ? await readStdinInput() : {};
+  const query = queryParts.join(" ") || stringValue(input.query) || "";
+  if (!query) {
+    throw inputError("Search query is required");
+  }
+  const modeValue = options.mode ?? stringValue(input.mode) ?? "fast";
+  const split = parsePositiveInteger(options.split ?? input.split, "split");
+  const num = parsePositiveInteger(options.num ?? input.num, "num");
+  return {
+    query,
+    mode: parseMode(modeValue),
+    model: options.model ?? stringValue(input.model) ?? void 0,
+    ...split !== void 0 ? { split } : {},
+    ...num !== void 0 ? { num } : {}
+  };
+}
+async function readStdinInput() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  if (!text) {
+    throw inputError("Expected JSON on stdin because --stdin was provided");
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("stdin JSON must be an object");
     }
-  } catch (e) {
-    output(error("search", "SEARCH_FAILED", e instanceof Error ? e.message : String(e)));
-    process.exit(3);
+    return parsed;
+  } catch (err) {
+    throw inputError(
+      `Failed to parse stdin JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
-await program.parseAsync(process.argv);
+function parseMode(value) {
+  if (SEARCH_MODES.includes(value)) {
+    return value;
+  }
+  throw inputError(`Unsupported search mode: ${value}`);
+}
+function parsePositiveInteger(value, name) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const normalized = typeof value === "number" ? String(value) : String(value).trim();
+  if (!/^[1-9]\d*$/.test(normalized)) {
+    throw inputError(`${name} must be a positive integer`);
+  }
+  return Number.parseInt(normalized, 10);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function mask(token) {
+  if (token.length <= 12) {
+    return "***";
+  }
+  return `${token.slice(0, 8)}...${token.slice(-4)}`;
+}
+function printError(commandName, err, human = false) {
+  const normalized = normalizeError(err);
+  output(
+    error(commandName, normalized.code, normalized.message, normalized.suggestion),
+    human
+  );
+  process.exit(normalized.exitCode);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doufunao123/ai-search",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AI-powered web search CLI with query splitting",
   "type": "module",
   "bin": {