ccjk 9.7.0 → 9.8.1

package/dist/{shared/ccjk.q1koQxEE.mjs → chunks/smart-defaults.mjs}

@@ -2,20 +2,21 @@ import { execSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'pathe';
-import { b as getPlatform } from '../chunks/platform.mjs';
-import { DEFAULT_CODE_TOOL_TYPE } from '../chunks/constants.mjs';
-import { i18n } from '../chunks/index.mjs';
-import { readZcfConfigAsync, saveZcfConfig } from '../chunks/ccjk-config.mjs';
+import { d as getPlatform } from './platform.mjs';
+import { s as scanProject } from '../shared/ccjk.DKojSRzw.mjs';
+import 'node:process';
+import 'tinyexec';
 
 class SmartDefaultsDetector {
   /**
    * Detect environment and generate smart defaults
    */
-  async detect() {
+  async detect(cwd) {
     const platform = getPlatform();
     const apiKey = this.detectApiKey();
     const apiProvider = this.detectApiProvider(apiKey);
     const ccVersion = this.detectClaudeCodeVersion();
+    const projectContext = scanProject(cwd);
     return {
       // Environment detection
       platform,
@@ -23,18 +24,18 @@ class SmartDefaultsDetector {
       // API configuration
       apiKey,
       apiProvider,
-      // Recommended MCP services based on platform
-      mcpServices: this.getRecommendedMcpServices(platform),
-      // Essential skills (common 5)
-      skills: [
+      // Recommended MCP services based on platform + project
+      mcpServices: this.getRecommendedMcpServices(platform, projectContext),
+      // Essential skills — reduced in CI/container (non-interactive)
+      skills: projectContext.runtime.isCI || projectContext.runtime.isContainer ? ["ccjk:git-commit"] : [
         "ccjk:git-commit",
         "ccjk:feat",
         "ccjk:workflow",
         "ccjk:init-project",
         "ccjk:git-worktree"
       ],
-      // Core agents (universal 2)
-      agents: [
+      // Core agents — skip in CI/container (non-interactive)
+      agents: projectContext.runtime.isCI || projectContext.runtime.isContainer ? [] : [
         "typescript-cli-architect",
         "ccjk-testing-specialist"
       ],
@@ -43,7 +44,7 @@ class SmartDefaultsDetector {
       // Workflow preferences
       workflows: {
         outputStyle: "engineer-professional",
-        gitWorkflow: "conventional-commits",
+        gitWorkflow: projectContext.usesConventionalCommits ? "conventional-commits" : "conventional-commits",
         sixStepWorkflow: true
       },
       // Tool integrations
@@ -54,7 +55,13 @@ class SmartDefaultsDetector {
       },
       // Claude Code native features
       claudeCodeVersion: ccVersion,
-      nativeFeatures: this.detectNativeFeatures(ccVersion)
+      nativeFeatures: this.detectNativeFeatures(ccVersion),
+      // Project context
+      projectContext,
+      // Recommended hooks based on project toolchain
+      recommendedHooks: this.getRecommendedHooks(projectContext),
+      // SSH session flag for quick-setup notice
+      sshDetected: projectContext.runtime.isSSH || void 0
     };
   }
   /**
@@ -200,20 +207,67 @@ class SmartDefaultsDetector {
     return ccusagePaths.some((path) => existsSync(path));
   }
   /**
-   * Get recommended MCP services based on environment
+   * Get recommended MCP services based on environment + project context
    */
-  getRecommendedMcpServices(platform) {
+  getRecommendedMcpServices(platform, project) {
+    const runtime = project?.runtime;
+    if (runtime?.isCI) {
+      return ["context7", "mcp-deepwiki"];
+    }
+    if (runtime?.isContainer) {
+      return ["context7", "mcp-deepwiki"];
+    }
     const core = ["context7", "mcp-deepwiki", "open-websearch"];
-    if (platform === "darwin") {
-      return [...core, "Playwright", "sqlite"];
+    const extras = [];
+    const hasBrowser = runtime?.hasBrowser ?? (platform === "darwin" || platform === "win32");
+    if (hasBrowser) {
+      extras.push("Playwright");
+    }
+    extras.push("sqlite");
+    if (project && ["typescript", "java", "csharp"].includes(project.language)) {
+      if (!runtime?.isHeadless) {
+        extras.push("serena");
+      }
     }
-    if (platform === "linux") {
-      return [...core, "sqlite"];
+    return [...core, ...extras];
+  }
+  /**
+   * Get recommended hook template IDs based on project toolchain
+   */
+  getRecommendedHooks(project) {
+    const runtime = project.runtime;
+    if (runtime.isCI) {
+      const hooks2 = [];
+      if (project.linter !== "none") hooks2.push("pre-commit-lint-check");
+      if (project.testRunner !== "none") hooks2.push("test-before-commit");
+      return hooks2;
     }
-    if (platform === "win32") {
-      return [...core, "Playwright", "sqlite"];
+    if (runtime.isContainer) {
+      const hooks2 = [];
+      if (project.linter !== "none") hooks2.push("pre-commit-lint-check");
+      if (project.testRunner !== "none") hooks2.push("test-before-commit");
+      return hooks2;
     }
-    return core;
+    const hooks = [];
+    if (!runtime.isHeadless) {
+      hooks.push("block-dev-server");
+    }
+    hooks.push("git-push-confirm");
+    const jsLangs = ["typescript", "javascript"];
+    if (jsLangs.includes(project.language)) {
+      hooks.push("warn-console-log");
+    }
+    hooks.push("block-unwanted-docs");
+    if (project.testRunner !== "none") {
+      hooks.push("test-before-commit");
+    }
+    if (project.formatter !== "none") {
+      hooks.push("auto-format-on-save");
+    }
+    if (project.linter !== "none") {
+      hooks.push("pre-commit-lint-check");
+    }
+    return hooks;
   }
   /**
    * Get recommended skills based on user type
@@ -273,60 +327,4 @@ function detectCodeToolType() {
   return SmartDefaultsDetector.detectCodeToolType();
 }
 
-const CODE_TYPE_ABBREVIATIONS = {
-  cc: "claude-code",
-  cx: "codex"
-};
-async function resolveCodeType(codeTypeParam) {
-  if (codeTypeParam) {
-    const normalizedParam = codeTypeParam.toLowerCase().trim();
-    if (normalizedParam in CODE_TYPE_ABBREVIATIONS) {
-      return CODE_TYPE_ABBREVIATIONS[normalizedParam];
-    }
-    if (isValidCodeType(normalizedParam)) {
-      return normalizedParam;
-    }
-    const validAbbreviations = Object.keys(CODE_TYPE_ABBREVIATIONS);
-    const validFullTypes = Object.values(CODE_TYPE_ABBREVIATIONS);
-    const validOptions = [...validAbbreviations, ...validFullTypes].join(", ");
-    let defaultValue = DEFAULT_CODE_TOOL_TYPE;
-    try {
-      const config = await readZcfConfigAsync();
-      if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
-        defaultValue = config.codeToolType;
-      }
-    } catch {
-    }
-    throw new Error(
-      i18n.t("errors:invalidCodeType", { value: codeTypeParam, validOptions, defaultValue })
-    );
-  }
-  try {
-    const freshDetected = detectCodeToolType();
-    if (isValidCodeType(freshDetected)) {
-      try {
-        const config = await readZcfConfigAsync();
-        if (config && config.codeToolType !== freshDetected) {
-          config.codeToolType = freshDetected;
-          await saveZcfConfig(config);
-        }
-      } catch {
-      }
-      return freshDetected;
-    }
-  } catch {
-  }
-  try {
-    const config = await readZcfConfigAsync();
-    if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
-      return config.codeToolType;
-    }
-  } catch {
-  }
-  return DEFAULT_CODE_TOOL_TYPE;
-}
-function isValidCodeType(value) {
-  return ["claude-code", "codex"].includes(value);
-}
-
-export { detectSmartDefaults as d, resolveCodeType as r };
+export { SmartDefaultsDetector, detectCodeToolType, detectSmartDefaults };

package/dist/chunks/status.mjs

@@ -1,10 +1,12 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import process__default from 'node:process';
 import ansis from 'ansis';
-import { r as runHealthCheck, a as analyzeProject, g as getRecommendations } from '../shared/ccjk.CSkyCZIM.mjs';
-import 'node:fs';
-import 'node:process';
-import 'pathe';
+import { join } from 'pathe';
+import { s as scanProject } from '../shared/ccjk.DKojSRzw.mjs';
+import { r as runHealthCheck } from '../shared/ccjk.Bndhan7G.mjs';
+import 'node:child_process';
 import './constants.mjs';
-import 'node:os';
 import './index.mjs';
 import 'node:url';
 import 'i18next';
@@ -23,18 +25,19 @@ const STATUS_ICONS = {
   warn: ansis.yellow("\u26A0"),
   fail: ansis.red("\u2717")
 };
-function stripAnsi(s) {
-  return s.replace(/\x1B\[[0-9;]*m/g, "");
+const INSTALLED = ansis.green("\u2713");
+const MISSING = ansis.gray("\u2212");
+function label(text) {
+  return ansis.gray(text);
 }
-function renderBox(lines, width = 55) {
-  const top = ansis.gray(`\u256D${"\u2500".repeat(width - 2)}\u256E`);
-  const bot = ansis.gray(`\u2570${"\u2500".repeat(width - 2)}\u256F`);
-  const pad = (s) => {
-    const stripped = stripAnsi(s);
-    const remaining = width - 4 - stripped.length;
-    return `${ansis.gray("\u2502")}  ${s}${" ".repeat(Math.max(0, remaining))}  ${ansis.gray("\u2502")}`;
-  };
-  return [top, ...lines.map(pad), bot].join("\n");
+function val(text) {
+  return ansis.white(text);
+}
+function heading(text) {
+  return ansis.cyan.bold(text);
+}
+function divider() {
+  return ansis.gray("\u2500".repeat(44));
 }
 function renderScoreBar(score) {
   const filled = Math.round(score / 5);
@@ -48,112 +51,211 @@ function renderScoreBar(score) {
   bar += ansis.gray("\u2591".repeat(empty));
   return bar;
 }
-function renderHeader(report, profile) {
-  const gradeColor = GRADE_COLORS[report.grade] || ((s) => s);
+function loadInstalledSettings() {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  try {
+    if (!existsSync(settingsPath)) return { mcpServers: {}, hooks: {} };
+    const data = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    return {
+      mcpServers: data.mcpServers || {},
+      hooks: data.hooks || {}
+    };
+  } catch {
+    return { mcpServers: {}, hooks: {} };
+  }
+}
+async function loadSmartDefaults() {
+  try {
+    const { detectSmartDefaults } = await import('./smart-defaults.mjs');
+    return await detectSmartDefaults();
+  } catch {
+    return null;
+  }
+}
+function renderProjectSection(ctx) {
   const lines = [];
-  lines.push("");
-  lines.push(ansis.cyan.bold("\u{1F9E0} CCJK Brain Dashboard"));
-  lines.push("");
-  lines.push(`${renderScoreBar(report.totalScore)}  ${gradeColor(report.grade)} ${ansis.bold(`${report.totalScore}/100`)}`);
-  lines.push("");
-  if (profile.projectName) {
-    const stackParts = [];
-    if (profile.language !== "unknown")
-      stackParts.push(profile.language);
-    stackParts.push(...profile.frameworks.slice(0, 3));
-    const stack = stackParts.length > 0 ? ansis.gray(` (${stackParts.join(", ")})`) : "";
-    lines.push(ansis.gray("Project: ") + ansis.white(profile.projectName) + stack);
+  lines.push(heading("Project"));
+  const fields = [
+    ["Language", ctx.language],
+    ["Framework", ctx.framework],
+    ["Test Runner", ctx.testRunner],
+    ["Pkg Manager", ctx.packageManager],
+    ["Linter", ctx.linter],
+    ["Formatter", ctx.formatter],
+    ["Database", ctx.database === "none" ? "none" : ctx.database]
+  ];
+  for (const [k, v] of fields) {
+    const display = v === "none" || v === "unknown" ? ansis.gray(v) : val(v);
+    lines.push(`  ${label(`${k}:`.padEnd(14))} ${display}`);
+  }
+  const flags = [];
+  if (ctx.isMonorepo) flags.push("monorepo");
+  if (ctx.hasDocker) flags.push("docker");
+  if (ctx.hasCI) flags.push("CI");
+  if (ctx.hasGitHooks) flags.push("git-hooks");
+  if (ctx.usesConventionalCommits) flags.push("conventional-commits");
+  if (flags.length > 0) {
+    lines.push(`  ${label("Flags:".padEnd(14))} ${val(flags.join(", "))}`);
   }
   return lines;
 }
-function renderSetupStatus(results) {
+function renderRuntimeSection(ctx) {
   const lines = [];
-  lines.push("");
-  lines.push(ansis.yellow.bold("Setup Status"));
-  lines.push("");
-  for (const r of results) {
-    const icon = STATUS_ICONS[r.status] || "?";
-    const name = r.name.padEnd(16);
-    const msg = r.status === "pass" ? ansis.green(r.message) : r.status === "warn" ? ansis.yellow(r.message) : ansis.red(r.message);
-    lines.push(`${icon} ${ansis.bold(name)} ${msg}`);
+  lines.push(heading("Runtime"));
+  const rt = ctx.runtime;
+  lines.push(`  ${label("Platform:".padEnd(14))} ${val(process__default.platform)} ${ansis.gray(`(${process__default.arch})`)}`);
+  const envFlags = [];
+  if (rt.isContainer) envFlags.push("container");
+  if (rt.isHeadless) envFlags.push("headless");
+  if (rt.isSSH) envFlags.push("SSH");
+  if (rt.isCI) envFlags.push("CI");
+  if (rt.isWSL) envFlags.push("WSL");
+  if (envFlags.length > 0) {
+    lines.push(`  ${label("Environment:".padEnd(14))} ${val(envFlags.join(", "))}`);
+  } else {
+    lines.push(`  ${label("Environment:".padEnd(14))} ${ansis.gray("standard")}`);
   }
+  lines.push(`  ${label("Browser:".padEnd(14))} ${rt.hasBrowser ? ansis.green("available") : ansis.gray("unavailable")}`);
   return lines;
 }
-function renderRecommendations(recs, maxShow = 4) {
-  if (recs.length === 0)
-    return [];
+function renderMcpSection(recommended, installed) {
   const lines = [];
-  lines.push("");
-  lines.push(ansis.yellow.bold("Recommendations"));
-  lines.push("");
-  for (const rec of recs.slice(0, maxShow)) {
-    const icon = rec.priority === "high" ? ansis.red("\u2192") : ansis.yellow("\u2192");
-    lines.push(`${icon} ${rec.description}`);
-    if (rec.command) {
-      lines.push(`  ${ansis.cyan(rec.command)}`);
-    }
+  lines.push(heading("MCP Services"));
+  const installedNames = Object.keys(installed);
+  if (recommended.length === 0 && installedNames.length === 0) {
+    lines.push(`  ${ansis.gray("No MCP services detected")}`);
+    return lines;
   }
-  if (recs.length > maxShow) {
-    lines.push(ansis.gray(`  ... and ${recs.length - maxShow} more`));
+  const shown = /* @__PURE__ */ new Set();
+  for (const svc of recommended) {
+    const isInstalled = installedNames.some(
+      (name) => name.toLowerCase().includes(svc.toLowerCase()) || svc.toLowerCase().includes(name.toLowerCase())
+    );
+    const icon = isInstalled ? INSTALLED : MISSING;
+    lines.push(`  ${icon} ${isInstalled ? val(svc) : ansis.gray(svc)}`);
+    shown.add(svc.toLowerCase());
+  }
+  for (const name of installedNames) {
+    if (!shown.has(name.toLowerCase()) && !recommended.some((r) => r.toLowerCase() === name.toLowerCase())) {
+      lines.push(`  ${INSTALLED} ${val(name)} ${ansis.gray("(extra)")}`);
+    }
   }
   return lines;
 }
-function renderProjectRecs(profile) {
-  const { skills, mcpServices } = getRecommendations(profile);
-  if (skills.length === 0 && mcpServices.length === 0)
-    return [];
+function renderHooksSection(recommended, installed) {
   const lines = [];
-  lines.push("");
-  lines.push(ansis.yellow.bold("For Your Project"));
-  lines.push("");
-  if (skills.length > 0) {
-    lines.push(`${ansis.cyan(String(skills.length))} skills match your stack:`);
-    for (const s of skills.slice(0, 3)) {
-      lines.push(`  ${ansis.green("+")} ${s.name} ${ansis.gray(`- ${s.reason}`)}`);
+  lines.push(heading("Hooks"));
+  const installedEvents = Object.keys(installed);
+  const hasAnyHooks = installedEvents.length > 0;
+  if (recommended.length === 0 && !hasAnyHooks) {
+    lines.push(`  ${ansis.gray("No hooks detected")}`);
+    return lines;
+  }
+  for (const hookId of recommended) {
+    const isInstalled = hasAnyHooks;
+    const icon = isInstalled ? INSTALLED : MISSING;
+    lines.push(`  ${icon} ${isInstalled ? val(hookId) : ansis.gray(hookId)}`);
+  }
+  if (hasAnyHooks) {
+    const totalHookCount = installedEvents.reduce((sum, event) => {
+      const eventHooks = installed[event];
+      return sum + (Array.isArray(eventHooks) ? eventHooks.length : 0);
+    }, 0);
+    if (totalHookCount > 0) {
+      lines.push(`  ${ansis.gray(`${totalHookCount} hook(s) across ${installedEvents.length} event(s)`)}`);
     }
-    lines.push(`  ${ansis.cyan("ccjk ccjk:skills --dry-run")}`);
   }
-  if (mcpServices.length > 0) {
-    lines.push(`${ansis.cyan(String(mcpServices.length))} MCP services recommended`);
-    lines.push(`  ${ansis.cyan("ccjk ccjk:mcp --dry-run")}`);
+  return lines;
+}
+function renderClaudeCodeSection(defaults) {
+  const lines = [];
+  lines.push(heading("Claude Code"));
+  const version = defaults?.claudeCodeVersion;
+  lines.push(`  ${label("Version:".padEnd(14))} ${version ? val(version) : ansis.gray("not detected")}`);
+  if (defaults?.nativeFeatures) {
+    const nf = defaults.nativeFeatures;
+    const features = [];
+    if (nf.hooks) features.push("hooks");
+    if (nf.memory) features.push("memory");
+    if (nf.subagents) features.push("subagents");
+    if (nf.toolSearch) features.push("tool-search");
+    if (features.length > 0) {
+      lines.push(`  ${label("Features:".padEnd(14))} ${val(features.join(", "))}`);
+    }
   }
   return lines;
 }
-function renderQuickActions() {
-  return [
-    "",
-    ansis.yellow.bold("Quick Actions"),
-    "",
-    `${ansis.cyan("ccjk boost")}        Auto-apply recommendations`,
-    `${ansis.cyan("ccjk ccjk:skills")}  Install project-matched skills`,
-    `${ansis.cyan("ccjk ccjk:mcp")}     Install recommended MCP services`,
-    `${ansis.cyan("ccjk doctor")}       Full environment diagnostics`
-  ];
+function renderHealthSection(report, compact) {
+  const lines = [];
+  lines.push(heading("Brain Dashboard"));
+  const gradeColor = GRADE_COLORS[report.grade] || ((s) => s);
+  const scoreBar = renderScoreBar(report.totalScore);
+  lines.push(`  ${label("Score:".padEnd(14))} ${scoreBar} ${gradeColor(report.grade)} ${ansis.gray(`(${report.totalScore}/100)`)}`);
+  if (!compact) {
+    lines.push("");
+    for (const r of report.results) {
+      const icon = STATUS_ICONS[r.status];
+      const scoreText = ansis.gray(`${r.score}/${r.weight}`);
+      lines.push(`  ${icon} ${r.name.padEnd(18)} ${scoreText.padEnd(10)} ${ansis.gray(r.message)}`);
+    }
+  }
+  if (report.recommendations.length > 0) {
+    lines.push("");
+    lines.push(ansis.yellow.bold("  Recommendations:"));
+    for (const rec of report.recommendations.slice(0, 3)) {
+      const priority = rec.priority === "high" ? ansis.red("!") : rec.priority === "medium" ? ansis.yellow("\u2022") : ansis.gray("\xB7");
+      lines.push(`  ${priority} ${rec.title}`);
+      if (rec.command) {
+        lines.push(`    ${ansis.gray("\u2192")} ${ansis.cyan(rec.command)}`);
+      }
+    }
+  }
+  return lines;
 }
-async function status(options = {}) {
-  const [report, profile] = await Promise.all([
-    runHealthCheck(),
-    Promise.resolve(analyzeProject())
-  ]);
-  if (options.json) {
-    console.log(JSON.stringify({
-      score: report.totalScore,
-      grade: report.grade,
-      results: report.results.map((r) => ({ name: r.name, status: r.status, score: r.score, message: r.message })),
-      recommendations: report.recommendations,
-      project: { name: profile.projectName, language: profile.language, frameworks: profile.frameworks, tags: profile.tags }
-    }, null, 2));
-    return;
+async function statusCommand(options = {}) {
+  try {
+    const [ctx, defaults, installed, health] = await Promise.all([
+      scanProject(),
+      loadSmartDefaults(),
+      Promise.resolve(loadInstalledSettings()),
+      runHealthCheck()
+    ]);
+    if (options.json) {
+      console.log(JSON.stringify({
+        project: ctx,
+        smartDefaults: defaults,
+        installed,
+        health
+      }, null, 2));
+      return;
+    }
+    const sections = [];
+    sections.push(renderProjectSection(ctx));
+    sections.push(renderRuntimeSection(ctx));
+    if (defaults) {
+      sections.push(renderMcpSection(defaults.mcpServices, installed.mcpServers));
+      sections.push(renderHooksSection(defaults.recommendedHooks, installed.hooks));
+      sections.push(renderClaudeCodeSection(defaults));
+    } else {
+      sections.push(renderMcpSection([], installed.mcpServers));
+      sections.push(renderHooksSection([], installed.hooks));
+      sections.push(renderClaudeCodeSection(null));
+    }
+    sections.push(renderHealthSection(health, options.compact || false));
+    console.log();
+    for (let i = 0; i < sections.length; i++) {
+      console.log(sections[i].join("\n"));
+      if (i < sections.length - 1) {
+        console.log();
+        console.log(divider());
+        console.log();
+      }
+    }
+    console.log();
+  } catch (error) {
+    console.error(ansis.red("Error running status command:"), error);
+    process__default.exit(1);
   }
-  const allLines = [
-    ...renderHeader(report, profile),
-    ...renderSetupStatus(report.results),
-    ...renderRecommendations(report.recommendations),
-    ...renderProjectRecs(profile),
-    ...renderQuickActions(),
-    ""
-  ];
-  console.log(renderBox(allLines));
 }
 
-export { status };
+export { statusCommand };

package/dist/chunks/uninstall.mjs

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import { ZCF_CONFIG_FILE, DEFAULT_CODE_TOOL_TYPE, isCodeToolType } from './constants.mjs';
 import { i18n, ensureI18nInitialized } from './index.mjs';
 import { readZcfConfig } from './ccjk-config.mjs';
-import { r as resolveCodeType } from '../shared/ccjk.q1koQxEE.mjs';
+import { r as resolveCodeType } from '../shared/ccjk.CeE8RLG2.mjs';
 import { h as handleExitPromptError, a as handleGeneralError } from '../shared/ccjk.DvIrK0wz.mjs';
 import { a as addNumbersToChoices } from '../shared/ccjk.BFQ7yr5S.mjs';
 import { p as promptBoolean } from '../shared/ccjk.DHbrGcgg.mjs';
@@ -21,8 +21,10 @@ import 'smol-toml';
 import './fs-operations.mjs';
 import 'node:crypto';
 import 'node:fs/promises';
+import './smart-defaults.mjs';
 import 'node:child_process';
 import './platform.mjs';
+import '../shared/ccjk.DKojSRzw.mjs';
 import 'inquirer-toggle';
 import 'dayjs';
 import 'trash';

package/dist/chunks/version-checker.mjs

@@ -4,7 +4,7 @@ import * as path from 'node:path';
 import process__default from 'node:process';
 import { promisify } from 'node:util';
 import * as semver from 'semver';
-import { b as getPlatform, f as findCommandPath, e as getHomebrewCommandPaths } from './platform.mjs';
+import { d as getPlatform, f as findCommandPath, e as getHomebrewCommandPaths } from './platform.mjs';
 import 'node:os';
 import 'pathe';
 import 'tinyexec';

package/dist/cli.mjs

@@ -1258,9 +1258,9 @@ ${ansis.yellow("By Status:")}`);
       { flags: "--compact", description: "Compact output" }
     ],
     loader: async () => {
-      const { status } = await import('./chunks/status.mjs');
+      const { statusCommand } = await import('./chunks/status.mjs');
       return async (options) => {
-        await status({
+        await statusCommand({
           json: options.json,
           compact: options.compact
         });