@vtstech/pi-diag 1.0.3

package/diag.js

@@ -0,0 +1,512 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// .build-npm/diag/diag.temp.ts
+var diag_temp_exports = {};
+__export(diag_temp_exports, {
+  default: () => diag_temp_default
+});
+module.exports = __toCommonJS(diag_temp_exports);
+var fs = __toESM(require("node:fs"));
+var os = __toESM(require("node:os"));
+var path = __toESM(require("node:path"));
+var import_format = require("@vtstech/pi-shared/format");
+var import_ollama = require("@vtstech/pi-shared/ollama");
+var import_security = require("@vtstech/pi-shared/security");
+function diag_temp_default(pi) {
+  const branding = [
+    `  \u26A1 Pi Diagnostics v1.0.3`,
+    `  Written by VTSTech`,
+    `  GitHub: https://github.com/VTSTech`,
+    `  Website: www.vts-tech.org`
+  ].join("\n");
+  async function runDiagnostics(ctx) {
+    const lines = [];
+    let passCount = 0;
+    let failCount = 0;
+    let warnCount = 0;
+    lines.push(branding);
+    const check = (condition, passMsg, failMsg) => {
+      if (condition) {
+        lines.push((0, import_format.ok)(passMsg));
+        passCount++;
+      } else {
+        lines.push((0, import_format.fail)(failMsg));
+        failCount++;
+      }
+    };
+    const warning = (condition, msg) => {
+      if (condition) {
+        lines.push((0, import_format.warn)(msg));
+        warnCount++;
+      }
+    };
+    lines.push((0, import_format.section)("SYSTEM"));
+    const cpus2 = os.cpus();
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMem = totalMem - freeMem;
+    const memPct = (0, import_format.pct)(usedMem, totalMem);
+    lines.push((0, import_format.info)(`OS: ${os.type()} ${os.release()} ${os.arch()}`));
+    lines.push((0, import_format.info)(`CPU: ${cpus2.length}x ${cpus2[0]?.model || "unknown"}`));
+    lines.push((0, import_format.info)(`RAM: ${(0, import_format.bytesHuman)(usedMem)} / ${(0, import_format.bytesHuman)(totalMem)} (${memPct})`));
+    lines.push((0, import_format.info)(`Uptime: ${(0, import_format.msHuman)(os.uptime() * 1e3)}`));
+    lines.push((0, import_format.info)(`Node.js: ${process.version}`));
+    check(
+      totalMem >= 4 * 1024 * 1024 * 1024,
+      `Total RAM: ${(0, import_format.bytesHuman)(totalMem)} (\u22654GB)`,
+      `Total RAM: ${(0, import_format.bytesHuman)(totalMem)} \u2014 LOW (<4GB), may struggle with models`
+    );
+    warning(
+      totalMem > 0 && usedMem / totalMem > 0.85,
+      `RAM usage ${memPct} \u2014 HIGH, close apps or reduce model size`
+    );
+    warning(cpus2.length < 2, `Only ${cpus2.length} CPU core(s), inference will be slow`);
+    lines.push((0, import_format.section)("DISK"));
+    try {
+      const dfResult = await pi.exec("df", ["-h", "/"], { timeout: 5e3 });
+      if (dfResult.code === 0) {
+        const dfLines = dfResult.stdout.trim().split("\n");
+        if (dfLines.length > 1) {
+          const parts = dfLines[1].trim().split(/\s+/);
+          lines.push((0, import_format.info)(`Mount: ${parts[0] || "/"}`));
+          lines.push((0, import_format.info)(`Size: ${parts[1]}, Used: ${parts[2]}, Avail: ${parts[3]}, Use%: ${parts[4]}`));
+          const usePct = parseInt(parts[4]) || 0;
+          warning(usePct > 90, `Disk usage ${parts[4]} \u2014 LOW SPACE`);
+        }
+      }
+    } catch {
+      lines.push((0, import_format.warn)("Could not read disk info"));
+    }
+    lines.push((0, import_format.section)("OLLAMA"));
+    let ollamaOk = false;
+    let ollamaModels = [];
+    let ollamaVersion = "unknown";
+    const ollamaBaseUrl = (0, import_ollama.getOllamaBaseUrl)();
+    const isRemoteOllama = !ollamaBaseUrl.includes("localhost") && !ollamaBaseUrl.includes("127.0.0.1");
+    if (isRemoteOllama) {
+      const ollamaRoot = ollamaBaseUrl.replace(/\/v1\/?$/, "");
+      lines.push((0, import_format.info)(`Remote Ollama detected: ${ollamaBaseUrl}`));
+      try {
+        const startTime = Date.now();
+        const versionRes = await fetch(`${ollamaRoot}/api/version`, { signal: AbortSignal.timeout(1e4) });
+        const latency = Date.now() - startTime;
+        if (versionRes.ok) {
+          const versionData = await versionRes.json();
+          ollamaVersion = versionData.version || "unknown";
+          ollamaOk = true;
+          lines.push((0, import_format.ok)(`Remote Ollama running: ${ollamaVersion} (${(0, import_format.msHuman)(latency)} response time)`));
+        } else {
+          lines.push((0, import_format.fail)(`Remote Ollama returned status ${versionRes.status}`));
+        }
+      } catch (e) {
+        lines.push((0, import_format.fail)(`Remote Ollama not reachable: ${e.message || "unknown error"}`));
+      }
+      if (ollamaOk) {
+        try {
+          const tagsRes = await fetch(`${ollamaRoot}/api/tags`, { signal: AbortSignal.timeout(15e3) });
+          if (tagsRes.ok) {
+            const tagsData = await tagsRes.json();
+            ollamaModels = (tagsData.models || []).map((m) => m.name || m.model).filter(Boolean);
+            lines.push((0, import_format.info)(`Available models: ${ollamaModels.length}`));
+            ollamaModels.forEach((m) => lines.push((0, import_format.info)(`  \u2022 ${m}`)));
+            check(ollamaModels.length > 0, "Models found in Ollama", "No models pulled in Ollama");
+          }
+        } catch {
+          lines.push((0, import_format.warn)("Could not list remote Ollama models"));
+        }
+        try {
+          const psRes = await fetch(`${ollamaRoot}/api/ps`, { signal: AbortSignal.timeout(1e4) });
+          if (psRes.ok) {
+            const psData = await psRes.json();
+            const loaded = psData.models || [];
+            if (loaded.length > 0) {
+              lines.push((0, import_format.info)(`Loaded in VRAM: ${loaded[0].name || loaded[0].model || "unknown"}`));
+            } else {
+              lines.push((0, import_format.info)("No model currently loaded in Ollama"));
+            }
+          }
+        } catch {
+        }
+      }
+    } else {
+      try {
+        const startTime = Date.now();
+        const versionResult = await pi.exec("ollama", ["--version"], { timeout: 1e4 });
+        const latency = Date.now() - startTime;
+        if (versionResult.code === 0) {
+          ollamaVersion = versionResult.stdout.trim();
+          ollamaOk = true;
+          lines.push((0, import_format.ok)(`Ollama running: ${ollamaVersion} (${(0, import_format.msHuman)(latency)} response time)`));
+        } else {
+          lines.push((0, import_format.fail)(`Ollama error: ${versionResult.stderr.trim() || "non-zero exit code"}`));
+        }
+      } catch (e) {
+        lines.push((0, import_format.fail)(`Ollama not reachable: ${e.message || "unknown error"}`));
+      }
+      if (ollamaOk) {
+        try {
+          const listResult = await pi.exec("ollama", ["list"], { timeout: 15e3 });
+          if (listResult.code === 0) {
+            const modelLines = listResult.stdout.trim().split("\n").slice(1);
+            ollamaModels = modelLines.map((l) => l.trim().split(/\s+/)[0]).filter(Boolean);
+            lines.push((0, import_format.info)(`Available models: ${ollamaModels.length}`));
+            ollamaModels.forEach((m) => lines.push((0, import_format.info)(`  \u2022 ${m}`)));
+            check(ollamaModels.length > 0, "Models found in Ollama", "No models pulled in Ollama");
+          }
+        } catch {
+          lines.push((0, import_format.warn)("Could not list Ollama models"));
+        }
+        try {
+          const psResult = await pi.exec("ollama", ["ps"], { timeout: 1e4 });
+          if (psResult.code === 0) {
+            const psLines = psResult.stdout.trim().split("\n").slice(1);
+            if (psLines.length > 0) {
+              const loadedModel = psLines[0].trim().split(/\s+/)[0];
+              lines.push((0, import_format.info)(`Loaded in VRAM: ${loadedModel}`));
+            } else {
+              lines.push((0, import_format.warn)("No model currently loaded in Ollama"));
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    lines.push((0, import_format.section)("MODELS.JSON"));
+    const agentDir = path.join(os.homedir(), ".pi", "agent");
+    const modelsJsonPath = import_ollama.MODELS_JSON_PATH;
+    let configuredModels = [];
+    let modelsJson = null;
+    if (fs.existsSync(modelsJsonPath)) {
+      try {
+        modelsJson = JSON.parse(fs.readFileSync(modelsJsonPath, "utf-8"));
+        const providers = modelsJson.providers || {};
+        lines.push((0, import_format.info)(`Providers configured: ${Object.keys(providers).length}`));
+        for (const [providerName, providerConfig] of Object.entries(providers)) {
+          const cfg = providerConfig;
+          const models = cfg.models || [];
+          lines.push((0, import_format.info)(`  ${providerName}: ${cfg.baseUrl || "no baseUrl"}, ${models.length} models`));
+          for (const m of models) {
+            configuredModels.push(m.id);
+            const reasoning = m.reasoning ? " [reasoning]" : "";
+            lines.push((0, import_format.info)(`    \u2022 ${m.id}${reasoning}`));
+          }
+        }
+        check(
+          configuredModels.length > 0,
+          `${configuredModels.length} model(s) configured`,
+          "No models in models.json"
+        );
+        if (ollamaModels.length > 0) {
+          const missing = ollamaModels.filter((m) => !configuredModels.includes(m));
+          const extra = configuredModels.filter((m) => !ollamaModels.includes(m));
+          if (missing.length > 0) {
+            lines.push((0, import_format.warn)(`${missing.length} Ollama model(s) not in models.json: ${missing.join(", ")}`));
+            lines.push((0, import_format.info)("  \u2192 Run /ollama-sync to auto-sync"));
+          }
+          if (extra.length > 0) {
+            lines.push((0, import_format.warn)(`${extra.length} model(s) in models.json but not pulled in Ollama: ${extra.join(", ")}`));
+          }
+          if (missing.length === 0 && extra.length === 0) {
+            lines.push((0, import_format.ok)("models.json matches Ollama exactly"));
+            passCount++;
+          }
+        }
+      } catch (e) {
+        lines.push((0, import_format.fail)(`models.json parse error: ${e.message}`));
+      }
+    } else {
+      lines.push((0, import_format.fail)(`models.json not found at ${modelsJsonPath}`));
+      lines.push((0, import_format.info)("  \u2192 Run /ollama-sync to create it"));
+    }
+    lines.push((0, import_format.section)("SETTINGS"));
+    const settingsPath = path.join(agentDir, "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+        lines.push((0, import_format.info)("Global settings found:"));
+        for (const [key, val] of Object.entries(settings)) {
+          lines.push((0, import_format.info)(`  ${key}: ${JSON.stringify(val)}`));
+        }
+        check(true, "settings.json valid JSON", "");
+      } catch (e) {
+        lines.push((0, import_format.fail)(`settings.json parse error: ${e.message}`));
+      }
+    } else {
+      lines.push((0, import_format.warn)("No global settings.json found (using defaults)"));
+    }
+    lines.push((0, import_format.section)("EXTENSIONS"));
+    const extensionsDir = path.join(agentDir, "extensions");
+    const activeTools = pi.getActiveTools();
+    const allTools = pi.getAllTools();
+    const builtinTools = /* @__PURE__ */ new Set(["read", "bash", "edit", "write"]);
+    const extensionToolCount = activeTools.filter((t) => !builtinTools.has(t)).length;
+    const localExtFiles = fs.existsSync(extensionsDir) ? fs.readdirSync(extensionsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")) : [];
+    lines.push((0, import_format.info)(`Extension files in ${extensionsDir}: ${localExtFiles.length}`));
+    localExtFiles.forEach((f) => lines.push((0, import_format.info)(`  \u2022 ${f}`)));
+    if (localExtFiles.length > 0) {
+      check(true, `${localExtFiles.length} local extension(s) found`);
+    } else if (extensionToolCount > 0) {
+      lines.push((0, import_format.info)(`${extensionToolCount} extension tool(s) loaded from Pi package`));
+      check(true, `${extensionToolCount} extension(s) active via Pi package`);
+    } else {
+      check(false, "", "No extensions found");
+    }
+    lines.push((0, import_format.info)(`Active tools: ${activeTools.length}`));
+    if (activeTools.length > 0) {
+      activeTools.forEach((t) => lines.push((0, import_format.info)(`  \u2022 ${t}`)));
+    }
+    lines.push((0, import_format.info)(`Registered tools (all): ${allTools.length}`));
+    lines.push((0, import_format.section)("THEMES"));
+    const themesDir = path.join(agentDir, "themes");
+    if (fs.existsSync(themesDir)) {
+      const themeFiles = fs.readdirSync(themesDir).filter(
+        (f) => f.endsWith(".json")
+      );
+      lines.push((0, import_format.info)(`Theme files: ${themeFiles.length}`));
+      themeFiles.forEach((f) => {
+        try {
+          const theme = JSON.parse(fs.readFileSync(path.join(themesDir, f), "utf-8"));
+          lines.push((0, import_format.info)(`  \u2022 ${f} (name: "${theme.name || "unnamed"}")`));
+        } catch {
+          lines.push((0, import_format.warn)(`  \u2022 ${f} \u2014 INVALID JSON`));
+        }
+      });
+    } else {
+      lines.push((0, import_format.warn)(`Themes directory not found: ${themesDir}`));
+    }
+    lines.push((0, import_format.section)("SECURITY"));
+    const blockedCmdList = Array.from(import_security.BLOCKED_COMMANDS).sort();
+    lines.push((0, import_format.info)(`Command blocklist: ${blockedCmdList.length} commands blocked`));
+    const exampleCmds = blockedCmdList.filter((c) => ["rm", "sudo", "chmod", "curl", "wget", "eval"].includes(c));
+    if (exampleCmds.length > 0) {
+      lines.push((0, import_format.info)(`  Examples: ${exampleCmds.join(", ")}`));
+    }
+    check(
+      blockedCmdList.length > 0,
+      `Command blocklist active (${blockedCmdList.length} rules)`,
+      `Command blocklist is EMPTY \u2014 security risk!`
+    );
+    const blockedPatterns = Array.from(import_security.BLOCKED_URL_PATTERNS).sort();
+    lines.push((0, import_format.info)(`SSRF protection: ${blockedPatterns.length} hostname patterns blocked`));
+    const examplePatterns = blockedPatterns.filter(
+      (p) => ["localhost", "127.0.0.1", "169.254.169.254", "10.", "192.168.", "internal."].includes(p)
+    );
+    if (examplePatterns.length > 0) {
+      lines.push((0, import_format.info)(`  Examples: ${examplePatterns.join(", ")}`));
+    }
+    check(
+      blockedPatterns.length > 0,
+      `SSRF protection active (${blockedPatterns.length} patterns)`,
+      `SSRF blocklist is EMPTY \u2014 vulnerability risk!`
+    );
+    lines.push((0, import_format.info)("SSRF validation tests:"));
+    const ssrfTests = [
+      { url: "http://localhost:8080/api", expectBlocked: true },
+      { url: "http://169.254.169.254/latest/meta-data/", expectBlocked: true },
+      { url: "http://192.168.1.1/admin", expectBlocked: true },
+      { url: "https://api.example.com/data", expectBlocked: false }
+    ];
+    for (const test of ssrfTests) {
+      const result = (0, import_security.isSafeUrl)(test.url);
+      if (test.expectBlocked && !result.safe) {
+        lines.push((0, import_format.ok)(`  BLOCKED: ${test.url} \u2192 ${result.error}`));
+      } else if (!test.expectBlocked && result.safe) {
+        lines.push((0, import_format.ok)(`  ALLOWED: ${test.url}`));
+      } else {
+        lines.push((0, import_format.fail)(`  UNEXPECTED: ${test.url} \u2192 safe=${result.safe} (expected blocked=${test.expectBlocked})`));
+      }
+    }
+    lines.push((0, import_format.info)("Path validation tests:"));
+    const pathTests = [
+      { p: "/etc/passwd", expectValid: false },
+      { p: "/etc/shadow", expectValid: false },
+      { p: "../../etc/hosts", expectValid: false },
+      { p: "./test.txt", expectValid: true },
+      { p: "/tmp/output.log", expectValid: true },
+      { p: process.cwd(), expectValid: true }
+    ];
+    for (const test of pathTests) {
+      const result = (0, import_security.validatePath)(test.p);
+      if (result.valid === test.expectValid) {
+        if (test.expectValid) {
+          lines.push((0, import_format.ok)(`  ALLOWED: ${test.p}`));
+        } else {
+          lines.push((0, import_format.ok)(`  BLOCKED: ${test.p} \u2192 ${result.error}`));
+        }
+      } else {
+        lines.push((0, import_format.fail)(`  UNEXPECTED: ${test.p} \u2192 valid=${result.valid} (expected valid=${test.expectValid})`));
+      }
+    }
+    lines.push((0, import_format.info)("Command injection tests:"));
+    const cmdTests = [
+      { cmd: "ls; rm -rf /", expectSafe: false },
+      { cmd: "sudo chmod 777 /etc/passwd", expectSafe: false },
+      { cmd: "curl http://localhost/secret", expectSafe: false },
+      { cmd: "ls -la", expectSafe: true },
+      { cmd: "cat README.md", expectSafe: true },
+      { cmd: "echo hello", expectSafe: true }
+    ];
+    for (const test of cmdTests) {
+      const result = (0, import_security.sanitizeCommand)(test.cmd);
+      if (result.isSafe === test.expectSafe) {
+        if (test.expectSafe) {
+          lines.push((0, import_format.ok)(`  PASS: "${test.cmd}" \u2192 allowed`));
+        } else {
+          lines.push((0, import_format.ok)(`  BLOCKED: "${test.cmd}" \u2192 ${result.error}`));
+        }
+      } else {
+        lines.push((0, import_format.fail)(`  UNEXPECTED: "${test.cmd}" \u2192 safe=${result.isSafe} (expected safe=${test.expectSafe})`));
+      }
+    }
+    lines.push((0, import_format.info)("Audit log status:"));
+    const auditEntries = (0, import_security.readRecentAuditEntries)(50);
+    const auditLogPath = path.join(os.homedir(), ".pi", "agent", "audit.log");
+    if (fs.existsSync(auditLogPath)) {
+      lines.push((0, import_format.ok)(`Audit log exists: ${auditLogPath}`));
+      if (auditEntries.length > 0) {
+        lines.push((0, import_format.info)(`  Recent entries: ${auditEntries.length} (last 50)`));
+        const recentSample = auditEntries.slice(-3);
+        for (const entry of recentSample) {
+          const entryType = (entry.type ?? entry.action ?? entry.event ?? "unknown").toString();
+          const entryTime = (entry.timestamp ?? entry.time ?? "").toString();
+          lines.push((0, import_format.info)(`  \u2022 [${entryTime ? entryTime + "] " : ""}${entryType}`));
+        }
+      } else {
+        lines.push((0, import_format.info)("  No audit entries found (log is empty or unparseable)"));
+      }
+    } else {
+      lines.push((0, import_format.warn)(`Audit log not found at ${auditLogPath}`));
+      lines.push((0, import_format.info)("  \u2192 Audit logging will begin when security events occur"));
+    }
+    lines.push((0, import_format.section)("CURRENT SESSION"));
+    const model = ctx.model;
+    if (model) {
+      lines.push((0, import_format.info)(`Model: ${model.id || "unknown"}`));
+      lines.push((0, import_format.info)(`Provider: ${model.provider || "unknown"}`));
+      const BUILTIN_PROVIDERS = {
+        openrouter: { api: "openai-completions", baseUrl: "https://openrouter.ai/api/v1" },
+        anthropic: { api: "anthropic-messages", baseUrl: "https://api.anthropic.com" },
+        google: { api: "gemini", baseUrl: "https://generativelanguage.googleapis.com" },
+        openai: { api: "openai-completions", baseUrl: "https://api.openai.com" },
+        groq: { api: "openai-completions", baseUrl: "https://api.groq.com" },
+        deepseek: { api: "openai-completions", baseUrl: "https://api.deepseek.com" },
+        mistral: { api: "openai-completions", baseUrl: "https://api.mistral.ai" },
+        xai: { api: "openai-completions", baseUrl: "https://api.x.ai" },
+        together: { api: "openai-completions", baseUrl: "https://api.together.xyz" },
+        fireworks: { api: "openai-completions", baseUrl: "https://api.fireworks.ai" },
+        cohere: { api: "cohere-chat", baseUrl: "https://api.cohere.com" }
+      };
+      const providerName = model.provider || "";
+      const userProviderCfg = modelsJson ? (modelsJson.providers || {})[providerName] : null;
+      if (userProviderCfg) {
+        const apiMode = userProviderCfg.api || "not set";
+        const baseUrl = userProviderCfg.baseUrl || "not set";
+        lines.push((0, import_format.info)(`API mode: ${apiMode} (models.json)`));
+        lines.push((0, import_format.info)(`Base URL: ${baseUrl}`));
+        if (userProviderCfg.apiKey) {
+          lines.push((0, import_format.info)(`API key: ****${String(userProviderCfg.apiKey).slice(-4)}`));
+        }
+      } else if (BUILTIN_PROVIDERS[providerName]) {
+        const builtin = BUILTIN_PROVIDERS[providerName];
+        lines.push((0, import_format.info)(`API mode: ${builtin.api} (built-in: ${providerName})`));
+        lines.push((0, import_format.info)(`Base URL: ${builtin.baseUrl}`));
+      } else if (providerName) {
+        lines.push((0, import_format.info)(`API mode: unknown \u2014 provider "${providerName}" not in models.json or built-in list`));
+      } else {
+        lines.push((0, import_format.info)(`API mode: unknown \u2014 no provider configured`));
+      }
+      lines.push((0, import_format.info)(`Context window: ${model.contextWindow ?? "unknown"}`));
+      lines.push((0, import_format.info)(`Max tokens: ${model.maxTokens ?? "unknown"}`));
+    } else {
+      lines.push((0, import_format.warn)("No model selected"));
+    }
+    const usage = ctx.getContextUsage?.();
+    if (usage && usage.contextWindow > 0) {
+      lines.push((0, import_format.info)(`Context: ${usage.tokens ?? "?"} / ${usage.contextWindow} tokens (${(usage.tokens / usage.contextWindow * 100).toFixed(1)}%)`));
+    }
+    const thinking = pi.getThinkingLevel();
+    lines.push((0, import_format.info)(`Thinking level: ${thinking}`));
+    lines.push((0, import_format.section)("SUMMARY"));
+    lines.push((0, import_format.info)(`Passed: ${passCount}  Failed: ${failCount}  Warnings: ${warnCount}`));
+    if (failCount === 0) {
+      lines.push((0, import_format.ok)("All critical checks passed! \u{1F389}"));
+    } else {
+      lines.push((0, import_format.fail)(`${failCount} check(s) failed \u2014 see above for details`));
+    }
+    if (warnCount > 0) {
+      lines.push((0, import_format.warn)(`${warnCount} warning(s) \u2014 non-critical but worth addressing`));
+    }
+    lines.push(branding);
+    return lines.join("\n");
+  }
+  pi.registerCommand("diag", {
+    description: "Run a full system diagnostic (Ollama, models, extensions, themes, resources, security)",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Diagnostic requires TUI mode", "error");
+        return;
+      }
+      ctx.ui.notify("Running diagnostic...", "info");
+      try {
+        const report = await runDiagnostics(ctx);
+        pi.sendMessage({
+          customType: "diagnostic-report",
+          content: report,
+          display: { type: "content", content: report }
+        });
+      } catch (e) {
+        ctx.ui.notify(`Diagnostic failed: ${e.message}`, "error");
+      }
+    }
+  });
+  pi.registerTool({
+    name: "self_diagnostic",
+    label: "Self Diagnostic",
+    description: "Run a comprehensive diagnostic check on the Pi environment including system resources, Ollama status, model configuration, extensions, themes, security posture, and current session state. Use this whenever the user asks for a diagnostic, health check, or system status.",
+    promptSnippet: "self_diagnostic - run full system diagnostic check",
+    promptGuidelines: [
+      "When the user asks for a diagnostic, health check, or system test, call self_diagnostic."
+    ],
+    parameters: {},
+    execute: async (_toolCallId, _params, _signal, _onUpdate, ctx) => {
+      try {
+        const report = await runDiagnostics(ctx);
+        return {
+          content: [{ type: "text", text: report }],
+          isError: false
+        };
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: `Diagnostic failed: ${e.message}` }],
+          isError: true
+        };
+      }
+    }
+  });
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@vtstech/pi-diag",
+  "version": "1.0.3",
+  "description": "Diagnostics extension for Pi Coding Agent",
+  "main": "diag.js",
+  "keywords": ["pi-package", "pi-extensions"],
+  "license": "MIT",
+  "access": "public",
+  "author": "VTSTech",
+  "homepage": "https://www.vts-tech.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/VTSTech/pi-coding-agent"
+  },
+  "dependencies": {
+    "@vtstech/pi-shared": "1.0.3"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": ">=0.66"
+  },
+  "pi": {
+    "extensions": ["./diag.js"]
+  }
+}