@ahkohd/yagami 0.1.2

package/packages/pi-yagami-search/extensions/yagami-search.ts

@@ -0,0 +1,273 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+
+const YAGAMI_BASE = process.env.YAGAMI_URL || "http://127.0.0.1:43111";
+
+type YagamiResponse = {
+  ok?: boolean;
+  error?: string;
+  result?: unknown;
+};
+
+type RenderTheme = {
+  bold: (text: string) => string;
+  fg: (token: string, text: string) => string;
+};
+
+type RenderArgs = Record<string, unknown>;
+
+function asString(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function renderCallLine(toolName: string, value: unknown, theme: RenderTheme): Text {
+  return new Text(`${theme.bold(toolName)} ${theme.fg("muted", asString(value))}`, 0, 0);
+}
+
+async function yagamiPost(endpoint: string, body: Record<string, unknown>): Promise<unknown> {
+  const res = await fetch(`${YAGAMI_BASE}${endpoint}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Yagami error ${res.status}: ${text}`);
+  }
+
+  const data = (await res.json()) as YagamiResponse;
+  if (!data.ok) throw new Error(data.error || "Unknown yagami error");
+  return data.result;
+}
+
+function errResult(message: string) {
+  return { content: [{ type: "text" as const, text: message }], details: {}, isError: true };
+}
+
+function okResult(text: string) {
+  return { content: [{ type: "text" as const, text }], details: {} };
+}
+
+function formatResult(result: unknown): string {
+  if (typeof result === "string") return result;
+  if (isRecord(result) && typeof result.answer === "string") return result.answer;
+  if (isRecord(result) && typeof result.text === "string") return result.text;
+  return JSON.stringify(result, null, 2);
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "web_search",
+    label: "Yagami Search",
+    description:
+      "Search the web for any topic and get clean, ready-to-use content.\n\n" +
+      "Best for: Finding current information, news, facts, or answering questions about any topic.\n" +
+      "Returns: Clean text content from top search results, ready for LLM use.",
+    renderCall(args: RenderArgs, theme: RenderTheme) {
+      return renderCallLine("web_search", args.query, theme);
+    },
+    parameters: Type.Object({
+      query: Type.String({ description: "Web search query" }),
+    }),
+    async execute(_id, params) {
+      try {
+        const result = await yagamiPost("/search", { query: params.query });
+        return okResult(formatResult(result));
+      } catch (error: unknown) {
+        return errResult(`Search error: ${errorMessage(error)}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "get_code_context",
+    label: "Yagami Code Search",
+    description:
+      "Find code examples, documentation, and programming solutions. Searches GitHub, Stack Overflow, and official docs.\n\n" +
+      "Best for: Any programming question - API usage, library examples, code snippets, debugging help.\n" +
+      "Returns: Relevant code and documentation, formatted for easy reading.",
+    renderCall(args: RenderArgs, theme: RenderTheme) {
+      return renderCallLine("get_code_context", args.query, theme);
+    },
+    parameters: Type.Object({
+      query: Type.String({ description: "Search query for code context." }),
+    }),
+    async execute(_id, params) {
+      try {
+        const result = await yagamiPost("/code-context", { query: params.query });
+        return okResult(formatResult(result));
+      } catch (error: unknown) {
+        return errResult(`Code search error: ${errorMessage(error)}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "fetch_content",
+    label: "Yagami Fetch",
+    description:
+      "Get the full content of a specific webpage. Use when you have an exact URL.\n\n" +
+      "Best for: Extracting content from a known URL.\n" +
+      "Returns: Full text content and metadata from the page.",
+    renderCall(args: RenderArgs, theme: RenderTheme) {
+      return renderCallLine("fetch_content", args.url, theme);
+    },
+    parameters: Type.Object({
+      url: Type.String({ description: "URL to crawl and extract content from" }),
+      maxCharacters: Type.Optional(Type.Number({ description: "Maximum characters to extract (default: 3000)" })),
+    }),
+    async execute(_id, params) {
+      try {
+        const result = await yagamiPost("/fetch", {
+          url: params.url,
+          maxCharacters: params.maxCharacters || 3000,
+        });
+        return okResult(formatResult(result));
+      } catch (error: unknown) {
+        return errResult(`Fetch error: ${errorMessage(error)}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "company_research",
+    label: "Yagami Company Research",
+    description:
+      "Research any company to get business information, news, and insights.\n\n" +
+      "Best for: Learning about a company's products, services, recent news, or industry position.\n" +
+      "Returns: Company information from trusted business sources.",
+    renderCall(args: RenderArgs, theme: RenderTheme) {
+      return renderCallLine("company_research", args.companyName, theme);
+    },
+    parameters: Type.Object({
+      companyName: Type.String({ description: "Name of the company to research" }),
+    }),
+    async execute(_id, params) {
+      try {
+        const result = await yagamiPost("/company-research", { companyName: params.companyName });
+        return okResult(formatResult(result));
+      } catch (error: unknown) {
+        return errResult(`Company research error: ${errorMessage(error)}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "web_search_advanced",
+    label: "Yagami Advanced Search",
+    description:
+      "Advanced web search with full control over filters, domains, dates, and content options.\n\n" +
+      "Best for: When you need specific filters like date ranges, domain restrictions, or category filters.\n" +
+      "Not recommended for: Simple searches - use web_search instead.\n" +
+      "Returns: Search results with optional highlights, summaries, and subpage content.",
+    renderCall(args: RenderArgs, theme: RenderTheme) {
+      return renderCallLine("web_search_advanced", args.query, theme);
+    },
+    parameters: Type.Object({
+      query: Type.String({ description: "Search query" }),
+      includeDomains: Type.Optional(
+        Type.Array(Type.String(), { description: "Only include results from these domains" }),
+      ),
+      excludeDomains: Type.Optional(Type.Array(Type.String(), { description: "Exclude results from these domains" })),
+      category: Type.Optional(Type.String({ description: "Filter results to a specific category" })),
+    }),
+    async execute(_id, params) {
+      try {
+        const result = await yagamiPost("/search/advanced", params);
+        return okResult(formatResult(result));
+      } catch (error: unknown) {
+        return errResult(`Advanced search error: ${errorMessage(error)}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "find_similar",
+    label: "Yagami Similar",
+    description:
+      "Find web pages similar to a given URL. Useful for finding alternatives, related resources, or similar documentation.",
+    renderCall(args: RenderArgs, theme: RenderTheme) {
+      return renderCallLine("find_similar", args.url, theme);
+    },
+    parameters: Type.Object({
+      url: Type.String({ description: "URL to find similar pages for" }),
+    }),
+    async execute(_id, params) {
+      try {
+        const result = await yagamiPost("/find-similar", { url: params.url });
+        return okResult(formatResult(result));
+      } catch (error: unknown) {
+        return errResult(`Find similar error: ${errorMessage(error)}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "deep_research_start",
+    label: "Yagami Deep Research",
+    description:
+      "Start an AI research agent that searches, reads, and writes a detailed report.\n\n" +
+      "Best for: Complex research questions needing deep analysis and synthesis.\n" +
+      "Returns: Research ID - use deep_research_check to get results.\n" +
+      "Important: Call deep_research_check with the returned research ID to get the report.",
+    renderCall(args: RenderArgs, theme: RenderTheme) {
+      const preview = asString(args.instructions).slice(0, 80);
+      return renderCallLine("deep_research_start", preview, theme);
+    },
+    parameters: Type.Object({
+      instructions: Type.String({ description: "Complex research question or detailed instructions." }),
+      effort: Type.Optional(
+        StringEnum(["fast", "balanced", "thorough"] as const, {
+          description: "'fast', 'balanced', or 'thorough'. Default: fast",
+        }),
+      ),
+    }),
+    async execute(_id, params) {
+      try {
+        const result = await yagamiPost("/deep-research/start", {
+          instructions: params.instructions,
+          effort: params.effort || "fast",
+        });
+        return okResult(JSON.stringify(result, null, 2));
+      } catch (error: unknown) {
+        return errResult(`Research start error: ${errorMessage(error)}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "deep_research_check",
+    label: "Yagami Research Check",
+    description:
+      "Check status and get results from a deep research task.\n\n" +
+      "Best for: Getting the research report after calling deep_research_start.\n" +
+      "Returns: Research report when complete, or status update if still running.\n" +
+      "Important: Keep calling with the same research ID until status is 'completed'.",
+    renderCall(args: RenderArgs, theme: RenderTheme) {
+      return renderCallLine("deep_research_check", args.researchId, theme);
+    },
+    parameters: Type.Object({
+      researchId: Type.String({ description: "The research ID returned from deep_research_start" }),
+    }),
+    async execute(_id, params) {
+      try {
+        const result = await yagamiPost("/deep-research/check", { researchId: params.researchId });
+        return okResult(JSON.stringify(result, null, 2));
+      } catch (error: unknown) {
+        return errResult(`Research check error: ${errorMessage(error)}`);
+      }
+    },
+  });
+}

package/packages/pi-yagami-search/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ahkohd/pi-yagami-search",
+  "version": "0.1.2",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "description": "Pi package providing Yagami web search tools",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ahkohd/yagami.git",
+    "directory": "packages/pi-yagami-search"
+  },
+  "homepage": "https://github.com/ahkohd/yagami/tree/main/packages/pi-yagami-search",
+  "bugs": {
+    "url": "https://github.com/ahkohd/yagami/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "yagami",
+    "pi-extension",
+    "search"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "files": [
+    "extensions",
+    "README.md",
+    "package.json"
+  ]
+}

package/src/cli/theme.ts

@@ -0,0 +1,260 @@
+import type { RuntimeConfig } from "../types/config.js";
+
+const THEMES = {
+  ansi: {
+    domain: "3;94",
+    title: "97",
+    duration: "3;93",
+    error: "91",
+    dim: "2",
+    cyan: "96",
+    bold: "1",
+  },
+  none: {
+    domain: "",
+    title: "",
+    duration: "",
+    error: "",
+    dim: "",
+    cyan: "",
+    bold: "",
+  },
+} as const;
+
+const THEME_TOKENS = ["domain", "title", "duration", "error", "dim", "cyan", "bold"] as const;
+
+const FIXED_ICONS = {
+  success: "ok",
+  error: "x",
+  cache: "[cache]",
+  pass: "ok",
+  fail: "x",
+  bullet: "•",
+  web: "•",
+  webError: "•",
+  connector: "│",
+} as const;
+
+type ThemeTokenName = (typeof THEME_TOKENS)[number];
+type ThemeCodeMap = Record<ThemeTokenName, string>;
+
+function normalizeThemeCode(rawValue: unknown, token: ThemeTokenName, baseTheme: ThemeCodeMap): string | null {
+  if (rawValue === undefined || rawValue === null) return null;
+
+  const raw = String(rawValue).trim();
+  if (!raw) return null;
+
+  const hexMatch = raw.match(/^#?([0-9a-fA-F]{6})$/);
+  if (hexMatch) {
+    const hex = hexMatch[1];
+    if (!hex) return null;
+
+    const r = Number.parseInt(hex.slice(0, 2), 16);
+    const g = Number.parseInt(hex.slice(2, 4), 16);
+    const b = Number.parseInt(hex.slice(4, 6), 16);
+
+    if (![r, g, b].every((value) => Number.isFinite(value))) return null;
+
+    const stylePrefix = String(baseTheme[token] || "")
+      .split(";")
+      .filter((part) => part === "1" || part === "2" || part === "3")
+      .join(";");
+
+    const colorPart = `38;2;${r};${g};${b}`;
+    return stylePrefix ? `${stylePrefix};${colorPart}` : colorPart;
+  }
+
+  if (/^[0-9;]+$/.test(raw)) {
+    return raw;
+  }
+
+  return null;
+}
+
+function applyThemeOverrides(themeName: RuntimeConfig["theme"], overridesRaw: Record<string, string>): ThemeCodeMap {
+  const baseTheme = (THEMES[themeName] || THEMES.ansi) as ThemeCodeMap;
+  const overrides: Partial<ThemeCodeMap> = {};
+
+  for (const token of THEME_TOKENS) {
+    const code = normalizeThemeCode(overridesRaw[token], token, baseTheme);
+    if (code !== null) overrides[token] = code;
+  }
+
+  return {
+    ...baseTheme,
+    ...overrides,
+  };
+}
+
+function supportsColor(theme: RuntimeConfig["theme"]): boolean {
+  if (theme === "none") return false;
+  if (process.env.NO_COLOR !== undefined) return false;
+
+  const noColor = String(process.env.YAGAMI_NO_COLOR || "")
+    .trim()
+    .toLowerCase();
+
+  if (noColor === "1" || noColor === "true" || noColor === "yes") return false;
+
+  const forceColor = String(process.env.FORCE_COLOR || "").trim();
+  if (forceColor && forceColor !== "0") return true;
+
+  return Boolean(process.stdout.isTTY);
+}
+
+function colorize(text: string, code: string, enabled: boolean): string {
+  if (!enabled || !code) return text;
+  return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+function styleToken(text: string, token: ThemeTokenName, theme: ThemeCodeMap, colorEnabled: boolean): string {
+  return colorize(text, theme[token], colorEnabled);
+}
+
+function icon(name: keyof typeof FIXED_ICONS): string {
+  return FIXED_ICONS[name] || "";
+}
+
+export type ThemeIconName = keyof typeof FIXED_ICONS;
+
+export interface CliThemeRuntime {
+  colorEnabled: boolean;
+  icon: (name: ThemeIconName) => string;
+  styleDomain: (text: string) => string;
+  styleTitle: (text: string) => string;
+  styleDuration: (text: string) => string;
+  styleError: (text: string) => string;
+  styleDim: (text: string) => string;
+  styleDimItalic: (text: string) => string;
+  styleCyan: (text: string) => string;
+  styleBold: (text: string) => string;
+}
+
+export function createCliThemeRuntime(config: RuntimeConfig): CliThemeRuntime {
+  const activeThemeName = THEMES[config.theme] ? config.theme : "ansi";
+  const activeTheme = applyThemeOverrides(activeThemeName, config.themeTokens || {});
+  const colorEnabled = supportsColor(config.theme);
+
+  const style = (token: ThemeTokenName, text: string): string => styleToken(text, token, activeTheme, colorEnabled);
+
+  const styleDimItalic = (text: string): string => {
+    if (!colorEnabled) return text;
+
+    const dimCode = String(activeTheme.dim || "2");
+    const parts = dimCode.split(";").filter(Boolean);
+    if (!parts.includes("3")) parts.push("3");
+    return colorize(text, parts.join(";"), true);
+  };
+
+  return {
+    colorEnabled,
+    icon: (name: ThemeIconName) => icon(name),
+    styleDomain: (text: string) => style("domain", text),
+    styleTitle: (text: string) => style("title", text),
+    styleDuration: (text: string) => style("duration", text),
+    styleError: (text: string) => style("error", text),
+    styleDim: (text: string) => style("dim", text),
+    styleDimItalic,
+    styleCyan: (text: string) => style("cyan", text),
+    styleBold: (text: string) => style("bold", text),
+  };
+}
+
+function parseCliArgs(args: string[]): { positional: string[] } {
+  const positional: string[] = [];
+  for (const token of args) {
+    if (!token.startsWith("--")) positional.push(token);
+  }
+  return { positional };
+}
+
+export async function cmdTheme(
+  config: RuntimeConfig,
+  args: string[],
+  options: { asJson?: boolean; printUsage: () => void } = { printUsage: () => {} },
+): Promise<void> {
+  const asJson = options.asJson ?? false;
+  const { positional } = parseCliArgs(args);
+  const action = String(positional[0] || "preview")
+    .trim()
+    .toLowerCase();
+
+  if (action && action !== "preview") {
+    console.error("theme command supports: preview\n");
+    options.printUsage();
+    process.exitCode = 1;
+    return;
+  }
+
+  const activeThemeName = THEMES[config.theme] ? config.theme : "ansi";
+  const activeTheme = applyThemeOverrides(activeThemeName, config.themeTokens || {});
+  const colorEnabled = supportsColor(config.theme);
+
+  const samples: Record<ThemeTokenName, string> = {
+    domain: "example.com",
+    title: "Example page title",
+    duration: "1.4s",
+    error: "request failed",
+    dim: "secondary text",
+    cyan: "https://example.com",
+    bold: "strong label",
+  };
+
+  if (asJson) {
+    console.log(
+      JSON.stringify(
+        {
+          theme: activeThemeName,
+          themeName: activeThemeName,
+          requestedTheme: config.theme,
+          configFile: config.configFile,
+          overrides: config.themeTokens || {},
+          resolvedTokens: activeTheme,
+          samples,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  const styleBold = (text: string): string => styleToken(text, "bold", activeTheme, colorEnabled);
+  const styleDim = (text: string): string => styleToken(text, "dim", activeTheme, colorEnabled);
+  const styleDuration = (text: string): string => styleToken(text, "duration", activeTheme, colorEnabled);
+  const styleDimItalic = (text: string): string => {
+    if (!colorEnabled) return text;
+
+    const dimCode = String(activeTheme.dim || "2");
+    const parts = dimCode.split(";").filter(Boolean);
+    if (!parts.includes("3")) parts.push("3");
+    return colorize(text, parts.join(";"), true);
+  };
+
+  console.log(styleBold("Theme preview"));
+  console.log(styleDim(`theme=${config.theme} · config=${config.configFile}`));
+
+  for (const token of THEME_TOKENS) {
+    const sample = samples[token] || token;
+    const code = activeTheme[token] || "-";
+    const label = `${token}:`.padEnd(10, " ");
+    console.log(
+      `  ${styleDim(label)} ${styleToken(sample, token, activeTheme, colorEnabled)} ${styleDim(`(${code})`)}`,
+    );
+  }
+
+  const sampleSuccessDomain = styleToken("duckduckgo.com", "domain", activeTheme, colorEnabled);
+  const sampleSuccessTitle = styleToken("Google AI news March 2026 at DuckDuckGo", "title", activeTheme, colorEnabled);
+  const sampleErrorDomain = styleToken("deccanherald.com", "domain", activeTheme, colorEnabled);
+  const sampleError = styleToken("— Timeout 7000ms exceeded.", "error", activeTheme, colorEnabled);
+
+  console.log(`\n${styleDim("Stream markers:")}`);
+  console.log(`${icon("bullet")} ${sampleSuccessDomain} ${sampleSuccessTitle}`);
+  console.log(`${styleDim(icon("connector"))}`);
+  console.log(`${icon("bullet")} ${sampleErrorDomain} ${sampleError}`);
+
+  console.log(`\n${styleDim("Spinner line:")}`);
+  console.log(
+    `${styleDuration("⠋")} ${styleDim("Reading")} ${styleDimItalic("duckduckgo.com")} ${styleDim("·")} ${styleDim("1.2s")}`,
+  );
+}