@doufunao123/ai-search 0.1.0

package/README.md

@@ -0,0 +1,53 @@
+# @doufunao123/ai-search
+
+AI-powered web search CLI (npm package). Uses AI models with native web search capabilities via the xiaomao proxy.
+
+## Install
+
+```bash
+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
+```
+
+## Usage
+
+```bash
+# Simple search
+ai-search "latest AI news"
+
+# Choose model
+ai-search "query" --model grok-4.1-fast
+
+# Complex search with query splitting
+ai-search "comprehensive analysis of X" --split 3
+
+# JSON output (default in non-TTY)
+ai-search "query" --json
+
+# Human-readable output
+ai-search "query" --human
+
+# List models
+ai-search models
+
+# Show config
+ai-search config show
+```
+
+## Configuration
+
+Config file: `~/.config/ai-search/config.json`
+
+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`)
+
+Shares credentials with the Rust CLI (`~/.config/ai-search/config.toml`).

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// 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 SEARCH_MODELS = [
+  "grok-4.1-expert",
+  "grok-4.1-fast",
+  "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");
+}
+function configPath() {
+  return join(configDir(), "config.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
+  };
+  const path = configPath();
+  if (existsSync(path)) {
+    try {
+      const content = readFileSync(path, "utf8");
+      const parsed = JSON.parse(content);
+      Object.assign(defaults, parsed);
+    } catch {
+    }
+  }
+  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 {
+      }
+    }
+  }
+  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) {
+  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 });
+  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();
+}
+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) {
+  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) {
+      const data = result.data;
+      if (data.content) {
+        process.stdout.write(String(data.content) + "\n");
+      } else {
+        process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+      }
+    } else {
+      process.stderr.write(`\u2717 ${result.error.code}: ${result.error.message}
+`);
+      if (result.error.suggestion) {
+        process.stderr.write(`  \u2192 ${result.error.suggestion}
+`);
+      }
+    }
+  } else {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  }
+}
+
+// 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) {
+    program.help();
+    return;
+  }
+  await doSearch(query, opts);
+});
+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(" ");
+  }
+  await doSearch(query, opts);
+});
+program.command("models").description("List available search models").action(() => {
+  output(success("models", { models: SEARCH_MODELS }));
+});
+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 }));
+  })
+).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)"
+      })
+    );
+  })
+);
+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);
+  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));
+    }
+  } catch (e) {
+    output(error("search", "SEARCH_FAILED", e instanceof Error ? e.message : String(e)));
+    process.exit(3);
+  }
+}
+await program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@doufunao123/ai-search",
+  "version": "0.1.0",
+  "description": "AI-powered web search CLI with query splitting",
+  "type": "module",
+  "bin": {
+    "ai-search": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fran0220/agent-skills.git",
+    "directory": "ai-search/npm"
+  },
+  "author": "doufunao123",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "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"
+  }
+}