@tplog/pi-zendy 0.2.17 → 0.3.1

package/dist/config/store.js

@@ -0,0 +1,81 @@
+// Config store: read/write ~/.zendy/config.json with env override.
+// Priority: env vars > config file > defaults.
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CONFIG_DIR = join(homedir(), ".zendy");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+// ── Env overrides ─────────────────────────────────────────────────────
+function envZendeskConfig() {
+    const c = {};
+    const v = process.env;
+    if (v["ZENDY_ZENDESK_SUBDOMAIN"])
+        c.subdomain = v["ZENDY_ZENDESK_SUBDOMAIN"];
+    if (v["ZENDY_ZENDESK_EMAIL"])
+        c.email = v["ZENDY_ZENDESK_EMAIL"];
+    if (v["ZENDY_ZENDESK_API_TOKEN"])
+        c.apiToken = v["ZENDY_ZENDESK_API_TOKEN"];
+    return c;
+}
+function envKgConfig() {
+    const c = {};
+    const v = process.env;
+    if (v["ZENDY_KG_API_URL"])
+        c.apiUrl = v["ZENDY_KG_API_URL"];
+    if (v["ZENDY_KG_API_KEY"])
+        c.apiKey = v["ZENDY_KG_API_KEY"];
+    return c;
+}
+// ── File read ─────────────────────────────────────────────────────────
+function readConfigFile() {
+    try {
+        if (!existsSync(CONFIG_PATH))
+            return null;
+        const raw = readFileSync(CONFIG_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────
+export function getConfig() {
+    const fileConfig = readConfigFile() ?? {};
+    const envZ = envZendeskConfig();
+    const envK = envKgConfig();
+    return {
+        zendesk: {
+            ...fileConfig.zendesk,
+            ...envZ,
+        },
+        zendeskKg: {
+            ...fileConfig.zendeskKg,
+            ...envK,
+        },
+    };
+}
+export function getZendeskConfig() {
+    const c = getConfig().zendesk;
+    if (c?.subdomain && c?.email && c?.apiToken)
+        return c;
+    return undefined;
+}
+export function getZendeskKgConfig() {
+    const c = getConfig().zendeskKg;
+    if (c?.apiKey)
+        return c;
+    return undefined;
+}
+export function writeConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+export function configPath() {
+    return CONFIG_PATH;
+}
+export function configExists() {
+    return existsSync(CONFIG_PATH);
+}

package/dist/index.js

@@ -15,27 +15,13 @@ const VERSION = pkg.version;
 // Resolve package root (one level up from dist/)
 const PKG_ROOT = join(__dirname, "..");
 // Embedded file paths relative to package root
-const AGENTS_MD = join(PKG_ROOT, "agents.md");
-const SKILL_ZCLI = join(PKG_ROOT, "skills", "zendesk-cli", "SKILL.md");
-const SKILL_HELM_WATCHDOG = join(PKG_ROOT, "skills", "helm-watchdog", "SKILL.md");
-const SKILL_SOURCE_CHECK = join(PKG_ROOT, "skills", "source-check", "SKILL.md");
-const SKILL_ZENDESK_KG = join(PKG_ROOT, "skills", "zendesk-kg", "SKILL.md");
-const EXT_CUSTOM_HEADER = join(PKG_ROOT, "extensions", "custom-header.ts");
-const EXT_SOURCE_CLEANUP = join(PKG_ROOT, "extensions", "source-cleanup.ts");
-const EXT_STATUS = join(PKG_ROOT, "extensions", "status.ts");
+const EXT_ZENDY = join(PKG_ROOT, "extensions", "zendy.ts");
 function cacheDir() {
     return join(homedir(), ".zendy", VERSION);
 }
 // All source files that get extracted to cache
 const SOURCE_FILES = [
-    SKILL_ZCLI,
-    SKILL_HELM_WATCHDOG,
-    SKILL_SOURCE_CHECK,
-    SKILL_ZENDESK_KG,
-    EXT_CUSTOM_HEADER,
-    EXT_SOURCE_CLEANUP,
-    EXT_STATUS,
-    AGENTS_MD,
+    EXT_ZENDY,
 ];
 function contentHash() {
     const hash = createHash("sha256");
@@ -51,23 +37,9 @@ function ensureExtracted(base) {
     if (existsSync(marker) && readFileSync(marker, "utf-8").trim() === currentHash) {
         return;
     }
-    const skills = [
-        ["zendesk-cli", SKILL_ZCLI],
-        ["helm-watchdog", SKILL_HELM_WATCHDOG],
-        ["source-check", SKILL_SOURCE_CHECK],
-        ["zendesk-kg", SKILL_ZENDESK_KG],
-    ];
-    for (const [name, srcPath] of skills) {
-        const dir = join(base, "skills", name);
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(join(dir, "SKILL.md"), readFileSync(srcPath, "utf-8"));
-    }
     const extDir = join(base, "extensions");
     mkdirSync(extDir, { recursive: true });
-    writeFileSync(join(extDir, "custom-header.ts"), readFileSync(EXT_CUSTOM_HEADER, "utf-8"));
-    writeFileSync(join(extDir, "source-cleanup.ts"), readFileSync(EXT_SOURCE_CLEANUP, "utf-8"));
-    writeFileSync(join(extDir, "status.ts"), readFileSync(EXT_STATUS, "utf-8"));
-    writeFileSync(join(base, "agents.md"), readFileSync(AGENTS_MD, "utf-8"));
+    writeFileSync(join(extDir, "zendy.ts"), readFileSync(EXT_ZENDY, "utf-8"));
     writeFileSync(marker, currentHash);
 }
 function findPi() {
@@ -136,23 +108,11 @@ async function main() {
     const base = cacheDir();
     ensureExtracted(base);
     const pi = findPi();
-    const skillsDir = join(base, "skills");
-    const agentsPath = join(base, "agents.md");
     const extensionsDir = join(base, "extensions");
-    const skillNames = ["zendesk-cli", "helm-watchdog", "source-check", "zendesk-kg"];
     const args = [
-        "--no-skills",
-        "--extension",
-        join(extensionsDir, "custom-header.ts"),
         "--extension",
-        join(extensionsDir, "source-cleanup.ts"),
-        "--extension",
-        join(extensionsDir, "status.ts"),
+        join(extensionsDir, "zendy.ts"),
     ];
-    for (const name of skillNames) {
-        args.push("--skill", join(skillsDir, name));
-    }
-    args.push("--append-system-prompt", agentsPath);
     // Pass through all user arguments
     args.push(...filteredArgs);
     // Spawn pi, replacing this process (inherit stdio for interactive use)

package/dist/preflight.js

@@ -3,6 +3,8 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
+import { getConfig } from "./config/store.js";
+import { migrateLegacyConfig, getLegacyZendeskConfig, getLegacyKgEnv } from "./config/migrate.js";
 // ── Helpers ────────────────────────────────────────────────────────────
 function exec(cmd, args, timeoutMs = 5000) {
     return new Promise((resolve) => {
@@ -58,55 +60,130 @@ async function checkPi() {
     }
     return { ...base, status: "ok", hint: "" };
 }
-async function checkZcli() {
+function resolveZendeskConfig() {
+    // 1. zendy config (env or ~/.zendy/config.json)
+    const cfg = getConfig();
+    if (cfg.zendesk?.subdomain && cfg.zendesk?.email && cfg.zendesk?.apiToken) {
+        return { subdomain: cfg.zendesk.subdomain, email: cfg.zendesk.email, apiToken: cfg.zendesk.apiToken };
+    }
+    // 2. Try legacy migration
+    migrateLegacyConfig();
+    const cfg2 = getConfig();
+    if (cfg2.zendesk?.subdomain && cfg2.zendesk?.email && cfg2.zendesk?.apiToken) {
+        return { subdomain: cfg2.zendesk.subdomain, email: cfg2.zendesk.email, apiToken: cfg2.zendesk.apiToken };
+    }
+    // 3. Legacy zcli config
+    const legacy = getLegacyZendeskConfig();
+    if (legacy?.subdomain && legacy?.email && legacy?.api_token) {
+        return { subdomain: legacy.subdomain, email: legacy.email, apiToken: legacy.api_token };
+    }
+    return null;
+}
+async function checkZendesk() {
     const base = {
-        name: "zcli",
+        name: "zendesk",
         label: "Zendesk access",
         level: "core",
     };
-    // `zcli whoami` calls GET /api/v2/users/me.json — succeeds only if zcli is
-    // installed, configured, and the Zendesk credentials are actually accepted.
-    const result = await exec("zcli", ["whoami"], 8000);
-    if (result.code === 127) {
+    const cfg = resolveZendeskConfig();
+    if (!cfg) {
         return {
             ...base,
             status: "missing",
-            hint: "Install zcli: npm install -g @tplog/zendesk-cli\nThen run: zcli configure",
+            hint: "Zendesk credentials not configured.\nUse /zendy-config in pi, or set env: ZENDY_ZENDESK_SUBDOMAIN, ZENDY_ZENDESK_EMAIL, ZENDY_ZENDESK_API_TOKEN",
         };
     }
-    if (result.code === 0) {
-        return { ...base, status: "ok", hint: "" };
+    try {
+        const ctrl = new AbortController();
+        const timeout = setTimeout(() => ctrl.abort(), 10000);
+        const auth = "Basic " + Buffer.from(`${cfg.email}/token:${cfg.apiToken}`).toString("base64");
+        const response = await fetch(`https://${cfg.subdomain}.zendesk.com/api/v2/users/me.json`, {
+            headers: { Authorization: auth, Accept: "application/json", "User-Agent": "zendy-preflight" },
+            signal: ctrl.signal,
+        });
+        clearTimeout(timeout);
+        if (response.ok) {
+            const data = await response.json();
+            return { ...base, status: "ok", hint: `Authenticated as ${data.user?.email ?? "unknown"}` };
+        }
+        return {
+            ...base,
+            status: "auth_error",
+            hint: `Zendesk API returned ${response.status}. Check credentials in ~/.zendy/config.json or env vars.`,
+        };
     }
-    // zcli prints "Not configured..." to stderr from getConfig() when creds are absent.
-    if (result.stderr.includes("Not configured")) {
+    catch (e) {
+        const msg = e.message || String(e);
         return {
             ...base,
             status: "auth_error",
-            hint: "zcli is installed but Zendesk credentials are not configured.\nRun: zcli configure",
+            hint: `Zendesk API unreachable: ${msg.slice(0, 200)}`,
         };
     }
-    // Configured but the API call failed — likely bad creds (401) or network issue.
-    return {
-        ...base,
-        status: "auth_error",
-        hint: "zcli is configured but the Zendesk API check failed.\nRun `zcli whoami` to see the error (check credentials and network).",
-    };
 }
-async function checkZendeskKg() {
+function resolveKgConfig() {
+    // 1. zendy config
+    const cfg = getConfig();
+    if (cfg.zendeskKg?.apiKey)
+        return { apiUrl: cfg.zendeskKg.apiUrl, apiKey: cfg.zendeskKg.apiKey };
+    // 2. Try legacy migration
+    migrateLegacyConfig();
+    const cfg2 = getConfig();
+    if (cfg2.zendeskKg?.apiKey)
+        return { apiUrl: cfg2.zendeskKg.apiUrl, apiKey: cfg2.zendeskKg.apiKey };
+    // 3. Legacy .env
+    const legacy = getLegacyKgEnv();
+    if (legacy?.["RETRIEVER_API_KEY"]) {
+        return { apiUrl: legacy["RETRIEVER_API_URL"] || undefined, apiKey: legacy["RETRIEVER_API_KEY"] };
+    }
+    return null;
+}
+const DEFAULT_KG_API_URL = "https://zendesk-ticket-retriever.vercel.app";
+async function checkZendeskKgApi() {
     const base = {
         name: "zendesk-kg",
         label: "Zendesk Knowledge Graph",
         level: "enhanced",
     };
-    const result = await exec("zendesk-kg", ["--version"]);
-    if (result.code === 127) {
+    const cfg = resolveKgConfig();
+    if (!cfg) {
         return {
             ...base,
             status: "missing",
-            hint: "zendesk-kg not installed. Install with:\ncurl -fsSL https://raw.githubusercontent.com/sorphwer/zendesk-kg-cli-release/main/install.sh | sh\nThen run: zendesk-kg init",
+            hint: "Knowledge Graph API key not configured.\nUse /zendy-config in pi, or set env: ZENDY_KG_API_KEY",
+        };
+    }
+    try {
+        const ctrl = new AbortController();
+        const timeout = setTimeout(() => ctrl.abort(), 10000);
+        const baseUrl = cfg.apiUrl || DEFAULT_KG_API_URL;
+        const headers = {
+            Accept: "application/json",
+            Authorization: `Bearer ${cfg.apiKey}`,
+            "User-Agent": "zendy-preflight",
+        };
+        if (cfg.apiKey)
+            headers["x-api-key"] = cfg.apiKey;
+        const response = await fetch(`${baseUrl}/health`, { headers, signal: ctrl.signal });
+        clearTimeout(timeout);
+        if (response.ok) {
+            const data = await response.json();
+            return { ...base, status: "ok", hint: `Status: ${data.status ?? "ok"}` };
+        }
+        return {
+            ...base,
+            status: "auth_error",
+            hint: `KG API returned ${response.status}. Check credentials.`,
+        };
+    }
+    catch (e) {
+        const msg = e.message || String(e);
+        return {
+            ...base,
+            status: "auth_error",
+            hint: `KG API unreachable: ${msg.slice(0, 200)}`,
         };
     }
-    return { ...base, status: "ok", hint: "" };
 }
 async function checkGithub() {
     const base = {
@@ -136,7 +213,7 @@ async function checkGithub() {
 }
 // ── Preflight runner ───────────────────────────────────────────────────
 export async function runPreflight() {
-    const results = await Promise.all([checkPi(), checkZcli(), checkZendeskKg(), checkGithub()]);
+    const results = await Promise.all([checkPi(), checkZendesk(), checkZendeskKgApi(), checkGithub()]);
     const failed = results.filter((r) => r.status !== "ok");
     return {
         results,

package/extensions/commands.ts

@@ -0,0 +1,119 @@
+// Zendy slash commands — /zendy-config, /zendy-status.
+// Loaded by jiti as part of the zendy extension.
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getConfig, writeConfig, configPath, configExists } from "../dist/config/store.js";
+import { migrateLegacyConfig } from "../dist/config/migrate.js";
+import type { ZendyConfig } from "../dist/config/schema.js";
+import * as zendesk from "../dist/clients/zendesk.js";
+import * as kg from "../dist/clients/zendesk-kg.js";
+
+async function configCommand(_args: string, ctx: {
+  ui: {
+    select: (prompt: string, options: string[]) => Promise<string | undefined>;
+    input: (prompt: string, placeholder?: string) => Promise<string | undefined>;
+    notify: (msg: string, level: string) => void;
+  };
+}): Promise<void> {
+  const migrated = migrateLegacyConfig();
+  if (migrated?.migrated) {
+    ctx.ui.notify(`[zendy-config] Auto-imported credentials from ${migrated.source}`, "info");
+  }
+
+  const action = await ctx.ui.select("Zendy Config — what would you like to configure?", [
+    "Zendesk credentials",
+    "Knowledge Graph credentials",
+    "View current config",
+  ]);
+  if (!action) return;
+
+  const config: ZendyConfig = getConfig();
+
+  if (action === "Zendesk credentials") {
+    const subdomain = await ctx.ui.input("Zendesk subdomain (e.g., dify)", config.zendesk?.subdomain ?? "dify");
+    const email = await ctx.ui.input("Zendesk email address", config.zendesk?.email ?? "");
+    const apiToken = await ctx.ui.input("Zendesk API token", "");
+    config.zendesk = {
+      ...config.zendesk,
+      subdomain: subdomain || config.zendesk?.subdomain,
+      email: email || config.zendesk?.email,
+      apiToken: apiToken || config.zendesk?.apiToken,
+    };
+    writeConfig(config);
+    ctx.ui.notify("[zendy-config] Zendesk credentials saved.", "info");
+  } else if (action === "Knowledge Graph credentials") {
+    const apiUrl = await ctx.ui.input(
+      "Knowledge Graph API URL (leave empty for default)",
+      config.zendeskKg?.apiUrl ?? "https://zendesk-ticket-retriever.vercel.app",
+    );
+    const apiKey = await ctx.ui.input("Knowledge Graph API key", "");
+    config.zendeskKg = {
+      ...config.zendeskKg,
+      apiUrl: apiUrl || config.zendeskKg?.apiUrl,
+      apiKey: apiKey || config.zendeskKg?.apiKey,
+    };
+    writeConfig(config);
+    ctx.ui.notify("[zendy-config] Knowledge Graph credentials saved.", "info");
+  } else if (action === "View current config") {
+    const c = getConfig();
+    const lines: string[] = [];
+    lines.push(`Config file: ${configPath()}`);
+    lines.push(`Exists: ${configExists() ? "yes" : "no"}`);
+    lines.push(
+      `Zendesk: ${c.zendesk?.subdomain ? `subdomain=${c.zendesk.subdomain}, email=${c.zendesk.email?.replace(/(.).+(@.+)/, "$1***$2") ?? "not set"}` : "not configured"}`,
+    );
+    lines.push(
+      `KG: ${c.zendeskKg?.apiKey ? `apiKey=*** (set), apiUrl=${c.zendeskKg.apiUrl || "default"}` : "not configured"}`,
+    );
+    ctx.ui.notify(`[zendy-config]\n${lines.join("\n")}`, "info");
+  }
+}
+
+async function statusCommand(_args: string, ctx: {
+  ui: { notify: (msg: string, level: "info" | "error" | "warn") => void };
+}): Promise<void> {
+  const lines: string[] = [];
+  let hasIssue = false;
+
+  try {
+    const me = await zendesk.getMe();
+    lines.push(`  ✓ Zendesk — authenticated as ${me.user.email}`);
+  } catch (e) {
+    lines.push(`  ✗ Zendesk — ${(e as Error).message.split("\n")[0]}`);
+    hasIssue = true;
+  }
+
+  try {
+    const health = await kg.healthCheck();
+    lines.push(`  ✓ Knowledge Graph — ${health.status}`);
+  } catch (e) {
+    lines.push(`  ✗ Knowledge Graph — ${(e as Error).message.split("\n")[0]}`);
+    hasIssue = true;
+  }
+
+  try {
+    const r = await fetch("https://dify-helm-watchdog.vercel.app/api/v1/versions/latest?versionOnly=true");
+    lines.push(`  ✓ Helm Watchdog — latest chart: ${(await r.text()).trim()}`);
+  } catch (e) {
+    lines.push(`  ✗ Helm Watchdog — ${(e as Error).message.split("\n")[0]}`);
+    hasIssue = true;
+  }
+
+  const srcDir = process.env["ZENDY_SRC_DIR"];
+  lines.push(
+    srcDir ? `  ✓ Source workspace — ${srcDir}` : "  - Source workspace — not active (will be created on session start)",
+  );
+
+  ctx.ui.notify(`Zendy Status:\n${lines.join("\n")}`, hasIssue ? "error" : "info");
+}
+
+export function registerAllCommands(pi: ExtensionAPI): void {
+  pi.registerCommand("zendy-config", {
+    description: "Configure Zendesk and Knowledge Graph credentials",
+    handler: configCommand,
+  });
+  pi.registerCommand("zendy-status", {
+    description: "Check Zendy connectivity: Zendesk, KG, Helm Watchdog",
+    handler: statusCommand,
+  });
+}

package/extensions/tools.ts

@@ -0,0 +1,190 @@
+// Zendy tools — LLM-callable wrappers over direct API clients.
+// Loaded by jiti as part of the zendy extension.
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import * as zendesk from "../dist/clients/zendesk.js";
+import * as helm from "../dist/clients/helm-watchdog.js";
+import * as kg from "../dist/clients/zendesk-kg.js";
+
+function textResult(text: string, details: Record<string, unknown> = {}) {
+  return { content: [{ type: "text" as const, text }], details };
+}
+
+function registerZendeskTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zendy_ticket_get",
+    label: "Zendy Ticket",
+    description: "Fetch a Zendesk ticket with comments and user info via direct API. Prefer this over any CLI command for ticket analysis.",
+    promptSnippet: "Fetch Zendesk ticket, comments, and user details with zendy_ticket_get.",
+    promptGuidelines: [
+      "Use zendy_ticket_get when the user provides a Zendesk ticket ID. It returns ticket metadata, comments, requester, and assignee.",
+      "Base conclusions on the returned ticket and comments; do not rely on external commands.",
+    ],
+    parameters: Type.Object({
+      ticketId: Type.Number({ description: "Zendesk ticket ID" }),
+    }),
+    async execute(_toolCallId: string, params: { ticketId: number }, signal?: AbortSignal) {
+      const result = await zendesk.getTicketFull(params.ticketId, signal);
+      return textResult(
+        `Fetched Zendesk ticket #${result.ticket.id}: "${result.ticket.subject}" (${result.ticket.status}), ${result.comments?.length ?? 0} comments.`,
+        {
+          ticket: result.ticket,
+          comments: result.comments,
+          requester: result.requester,
+          assignee: result.assignee,
+        },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "zendy_ticket_search",
+    label: "Zendy Search",
+    description: "Search Zendesk tickets via direct API. For fresh/live Zendesk lookups, not historical semantic retrieval.",
+    promptSnippet: "Search live Zendesk tickets with zendy_ticket_search.",
+    parameters: Type.Object({
+      query: Type.String({ description: "Zendesk search query string" }),
+    }),
+    async execute(_toolCallId: string, params: { query: string }, signal?: AbortSignal) {
+      const result = await zendesk.searchTickets(params.query, signal);
+      return textResult(`Zendesk search returned ${result.count} results.`, { results: result.results, count: result.count });
+    },
+  });
+}
+
+function registerHelmTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zendy_helm_get",
+    label: "Zendy Helm",
+    description: "Query Dify Helm Watchdog API for chart metadata, values.yaml, images, and validation. Always provide the exact chart version.",
+    promptSnippet: "Query Helm chart data with zendy_helm_get.",
+    promptGuidelines: [
+      "Use zendy_helm_get to query Dify Helm chart metadata. Always pass the customer's exact version.",
+      "Defaults change between versions — never assume a config value without checking the right version.",
+    ],
+    parameters: Type.Object({
+      resource: Type.Union([
+        Type.Literal("version"),
+        Type.Literal("values"),
+        Type.Literal("images"),
+        Type.Literal("validation"),
+        Type.Literal("latest"),
+        Type.Literal("versions"),
+        Type.Literal("cache"),
+      ], { description: "Resource to fetch" }),
+      version: Type.Optional(Type.String({ description: "Chart version. Required for: version, values, images, validation" })),
+      validateImages: Type.Optional(Type.Boolean({ description: "For images: include pull-status validation", default: false })),
+      status: Type.Optional(Type.String({ description: "For validation: filter by MISSING etc." })),
+      versionOnly: Type.Optional(Type.Boolean({ description: "For latest: return plain version string only", default: false })),
+    }),
+    async execute(_toolCallId: string, params: {
+      resource: string;
+      version?: string;
+      validateImages?: boolean;
+      status?: string;
+      versionOnly?: boolean;
+    }, signal?: AbortSignal) {
+      const needsVersion = ["version", "values", "images", "validation"].includes(params.resource);
+      if (needsVersion && !params.version) {
+        throw new Error(`version is required when resource=${params.resource}`);
+      }
+
+      switch (params.resource) {
+        case "version": {
+          const data = await helm.getVersion(params.version!, signal);
+          return textResult(`Helm Watchdog version metadata for ${params.version}.`, { version: params.version, data });
+        }
+        case "values": {
+          const data = await helm.getValues(params.version!, signal);
+          return textResult(`Helm Watchdog values.yaml for ${params.version}.`, { version: params.version, data });
+        }
+        case "images": {
+          const data = await helm.getImages(params.version!, params.validateImages, signal);
+          return textResult(`Helm Watchdog images for ${params.version} (${data.length} images).`, { version: params.version, images: data });
+        }
+        case "validation": {
+          const data = await helm.getValidation(params.version!, params.status, signal);
+          return textResult(`Helm Watchdog validation for ${params.version}.`, { version: params.version, results: data });
+        }
+        case "latest": {
+          const data = await helm.getLatest(params.versionOnly, signal);
+          return textResult("Helm Watchdog latest version.", { data });
+        }
+        case "versions": {
+          const data = await helm.listVersions(signal);
+          return textResult(`Helm Watchdog cached versions (${data.length} entries).`, { versions: data });
+        }
+        case "cache": {
+          const data = await helm.getCache(signal);
+          return textResult("Helm Watchdog cache metadata.", { data });
+        }
+      }
+    },
+  });
+}
+
+function registerKnowledgeGraphTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zendy_kg_search",
+    label: "Zendy KG",
+    description: "Search the Zendesk Knowledge Graph for historically similar tickets via direct API. Always cite ticketId values from results.",
+    promptSnippet: "Search historical similar tickets with zendy_kg_search.",
+    promptGuidelines: [
+      "Use zendy_kg_search for historical similar-ticket retrieval. Cite ticketId values when summarizing.",
+      "Empty results do not prove no similar issue exists — the KG is a snapshot, not live Zendesk.",
+    ],
+    parameters: Type.Object({
+      query: Type.String({ description: "Natural-language description of the issue" }),
+      limit: Type.Optional(Type.Number({ description: "Max results 1-20", default: 5 })),
+      version: Type.Optional(Type.String({ description: "Filter by Dify version mentioned in tickets" })),
+      priority: Type.Optional(Type.String({ description: "Filter: low, normal, high, urgent" })),
+      status: Type.Optional(Type.String({ description: "Filter by ticket status: open, closed, pending, etc." })),
+    }),
+    async execute(_toolCallId: string, params: {
+      query: string;
+      limit?: number;
+      version?: string;
+      priority?: string;
+      status?: string;
+    }, signal?: AbortSignal) {
+      const limit = Math.min(Math.max(Math.trunc(params.limit ?? 5), 1), 20);
+      const result = await kg.search({
+        query: params.query,
+        topK: limit,
+        filter: {
+          ...(params.version ? { versions: [params.version] } : {}),
+          ...(params.priority ? { priority: params.priority } : {}),
+          ...(params.status ? { status: params.status } : {}),
+        },
+      }, signal);
+      return textResult(
+        `KG search returned ${result.results.length} results for "${result.queryText}". Cite ticketId values from details.results.`,
+        { results: result.results, queryText: result.queryText },
+      );
+    },
+  });
+}
+
+function registerSourceTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zendy_source_status",
+    label: "Zendy Source Status",
+    description: "Report the zendy source-analysis workspace path and whether source cloning is authorized.",
+    promptSnippet: "Check source workspace status with zendy_source_status.",
+    parameters: Type.Object({}),
+    async execute() {
+      return textResult("Source workspace status.", {
+        workspace: process.env["ZENDY_SRC_DIR"] ?? null,
+        note: "Source cloning/search requires explicit user permission per zendy workflow rules. Ask before cloning private source.",
+      });
+    },
+  });
+}
+
+export function registerAllTools(pi: ExtensionAPI): void {
+  registerZendeskTools(pi);
+  registerHelmTools(pi);
+  registerKnowledgeGraphTools(pi);
+  registerSourceTools(pi);
+}