@foxclicom/foxcli 2.1.89

package/dist/chunk-fpzax6rw.js

@@ -0,0 +1,225 @@
+// @bun
+import {
+  gt,
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-skctedsv.js";
+import {
+  require_semver
+} from "./chunk-0vkfrmqm.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-nxsh6de2.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-3r24h7t6.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/releaseNotes.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+function getChangelogCachePath() {
+  return join(getClaudeConfigHomeDir(), "cache", "changelog.md");
+}
+async function migrateChangelogFromConfig() {
+  const config = getGlobalConfig();
+  if (!config.cachedChangelog) {
+    return;
+  }
+  const cachePath = getChangelogCachePath();
+  try {
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, config.cachedChangelog, {
+      encoding: "utf-8",
+      flag: "wx"
+    });
+  } catch {}
+  saveGlobalConfig(({ cachedChangelog: _, ...rest }) => rest);
+}
+async function fetchAndStoreChangelog() {
+  if (getIsNonInteractiveSession()) {
+    return;
+  }
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  const response = await axios_default.get(RAW_CHANGELOG_URL);
+  if (response.status === 200) {
+    const changelogContent = response.data;
+    if (changelogContent === changelogMemoryCache) {
+      return;
+    }
+    const cachePath = getChangelogCachePath();
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, changelogContent, { encoding: "utf-8" });
+    changelogMemoryCache = changelogContent;
+    const changelogLastFetched = Date.now();
+    saveGlobalConfig((current) => ({
+      ...current,
+      changelogLastFetched
+    }));
+  }
+}
+async function getStoredChangelog() {
+  if (changelogMemoryCache !== null) {
+    return changelogMemoryCache;
+  }
+  const cachePath = getChangelogCachePath();
+  try {
+    const content = await readFile(cachePath, "utf-8");
+    changelogMemoryCache = content;
+    return content;
+  } catch {
+    changelogMemoryCache = "";
+    return "";
+  }
+}
+function getStoredChangelogFromMemory() {
+  return changelogMemoryCache ?? "";
+}
+function parseChangelog(content) {
+  try {
+    if (!content)
+      return {};
+    const releaseNotes = {};
+    const sections = content.split(/^## /gm).slice(1);
+    for (const section of sections) {
+      const lines = section.trim().split(`
+`);
+      if (lines.length === 0)
+        continue;
+      const versionLine = lines[0];
+      if (!versionLine)
+        continue;
+      const version = versionLine.split(" - ")[0]?.trim() || "";
+      if (!version)
+        continue;
+      const notes = lines.slice(1).filter((line) => line.trim().startsWith("- ")).map((line) => line.trim().substring(2).trim()).filter(Boolean);
+      if (notes.length > 0) {
+        releaseNotes[version] = notes;
+      }
+    }
+    return releaseNotes;
+  } catch (error) {
+    logError(toError(error));
+    return {};
+  }
+}
+function getRecentReleaseNotes(currentVersion, previousVersion, changelogContent = getStoredChangelogFromMemory()) {
+  try {
+    const releaseNotes = parseChangelog(changelogContent);
+    const baseCurrentVersion = import_semver.coerce(currentVersion);
+    const basePreviousVersion = previousVersion ? import_semver.coerce(previousVersion) : null;
+    if (!basePreviousVersion || baseCurrentVersion && gt(baseCurrentVersion.version, basePreviousVersion.version)) {
+      return Object.entries(releaseNotes).filter(([version]) => !basePreviousVersion || gt(version, basePreviousVersion.version)).sort(([versionA], [versionB]) => gt(versionA, versionB) ? -1 : 1).flatMap(([_, notes]) => notes).filter(Boolean).slice(0, MAX_RELEASE_NOTES_SHOWN);
+    }
+  } catch (error) {
+    logError(toError(error));
+    return [];
+  }
+  return [];
+}
+function getAllReleaseNotes(changelogContent = getStoredChangelogFromMemory()) {
+  try {
+    const releaseNotes = parseChangelog(changelogContent);
+    const sortedVersions = Object.keys(releaseNotes).sort((a, b) => gt(a, b) ? 1 : -1);
+    return sortedVersions.map((version) => {
+      const versionNotes = releaseNotes[version];
+      if (!versionNotes || versionNotes.length === 0)
+        return null;
+      const notes = versionNotes.filter(Boolean);
+      if (notes.length === 0)
+        return null;
+      return [version, notes];
+    }).filter((item) => item !== null);
+  } catch (error) {
+    logError(toError(error));
+    return [];
+  }
+}
+async function checkForReleaseNotes(lastSeenVersion, currentVersion = "2.1.888") {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog = "";
+    if (changelog) {
+      const commits = changelog.trim().split(`
+`).filter(Boolean);
+      return {
+        hasReleaseNotes: commits.length > 0,
+        releaseNotes: commits
+      };
+    }
+    return {
+      hasReleaseNotes: false,
+      releaseNotes: []
+    };
+  }
+  const cachedChangelog = await getStoredChangelog();
+  if (lastSeenVersion !== currentVersion || !cachedChangelog) {
+    fetchAndStoreChangelog().catch((error) => logError(toError(error)));
+  }
+  const releaseNotes = getRecentReleaseNotes(currentVersion, lastSeenVersion, cachedChangelog);
+  const hasReleaseNotes = releaseNotes.length > 0;
+  return {
+    hasReleaseNotes,
+    releaseNotes
+  };
+}
+function checkForReleaseNotesSync(lastSeenVersion, currentVersion = "2.1.888") {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog = "";
+    if (changelog) {
+      const commits = changelog.trim().split(`
+`).filter(Boolean);
+      return {
+        hasReleaseNotes: commits.length > 0,
+        releaseNotes: commits
+      };
+    }
+    return {
+      hasReleaseNotes: false,
+      releaseNotes: []
+    };
+  }
+  const releaseNotes = getRecentReleaseNotes(currentVersion, lastSeenVersion);
+  return {
+    hasReleaseNotes: releaseNotes.length > 0,
+    releaseNotes
+  };
+}
+var import_semver, MAX_RELEASE_NOTES_SHOWN = 5, CHANGELOG_URL = "https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md", RAW_CHANGELOG_URL = "https://raw.githubusercontent.com/anthropics/claude-code/refs/heads/main/CHANGELOG.md", changelogMemoryCache = null;
+var init_releaseNotes = __esm(() => {
+  init_axios();
+  init_state();
+  init_config();
+  init_envUtils();
+  init_errors();
+  init_log();
+  init_privacyLevel();
+  init_semver();
+  import_semver = __toESM(require_semver(), 1);
+});
+
+export { CHANGELOG_URL, migrateChangelogFromConfig, fetchAndStoreChangelog, getStoredChangelog, getStoredChangelogFromMemory, parseChangelog, getAllReleaseNotes, checkForReleaseNotes, checkForReleaseNotesSync, init_releaseNotes };

package/dist/chunk-fyc5fepv.js

@@ -0,0 +1,10 @@
+// @bun
+import"./chunk-qp2qdcda.js";
+
+// src/commands/assistant/assistant.ts
+var NewInstallWizard = () => null;
+var computeDefaultInstallDir = () => Promise.resolve("");
+export {
+  computeDefaultInstallDir,
+  NewInstallWizard
+};

package/dist/chunk-g0j0t6qk.js

@@ -0,0 +1,26 @@
+// @bun
+import {
+  exports_external,
+  init_external
+} from "./chunk-55wgxwa9.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/index.js
+var classic_default;
+var init_classic = __esm(() => {
+  init_external();
+  init_external();
+  classic_default = exports_external;
+});
+
+// node_modules/.bun/zod@4.3.6/node_modules/zod/v4/index.js
+var v4_default;
+var init_v4 = __esm(() => {
+  init_classic();
+  init_classic();
+  v4_default = classic_default;
+});
+
+export { v4_default, init_v4 };

package/dist/chunk-g1kkd3xm.js

@@ -0,0 +1,130 @@
+// @bun
+import {
+  asSystemPrompt,
+  extractTextContent,
+  init_claude,
+  init_messages1 as init_messages,
+  init_systemPromptType,
+  queryHaiku
+} from "./chunk-363p49h1.js";
+import {
+  init_json,
+  safeParseJSON
+} from "./chunk-e3g8q4cn.js";
+import {
+  init_v4
+} from "./chunk-g0j0t6qk.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/sessionTitle.ts
+function extractConversationText(messages) {
+  const parts = [];
+  for (const msg of messages) {
+    if (msg.type !== "user" && msg.type !== "assistant")
+      continue;
+    if ("isMeta" in msg && msg.isMeta)
+      continue;
+    if ("origin" in msg && msg.origin && msg.origin.kind !== "human")
+      continue;
+    const content = msg.message.content;
+    if (typeof content === "string") {
+      parts.push(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        if ("type" in block && block.type === "text" && "text" in block) {
+          parts.push(block.text);
+        }
+      }
+    }
+  }
+  const text = parts.join(`
+`);
+  return text.length > MAX_CONVERSATION_TEXT ? text.slice(-MAX_CONVERSATION_TEXT) : text;
+}
+async function generateSessionTitle(description, signal) {
+  const trimmed = description.trim();
+  if (!trimmed)
+    return null;
+  try {
+    const result = await queryHaiku({
+      systemPrompt: asSystemPrompt([SESSION_TITLE_PROMPT]),
+      userPrompt: trimmed,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" }
+          },
+          required: ["title"],
+          additionalProperties: false
+        }
+      },
+      signal,
+      options: {
+        querySource: "generate_session_title",
+        agents: [],
+        isNonInteractiveSession: getIsNonInteractiveSession(),
+        hasAppendSystemPrompt: false,
+        mcpTools: []
+      }
+    });
+    const text = extractTextContent(result.message.content);
+    const parsed = titleSchema().safeParse(safeParseJSON(text));
+    const title = parsed.success ? parsed.data.title.trim() || null : null;
+    logEvent("tengu_session_title_generated", { success: title !== null });
+    return title;
+  } catch (error) {
+    logForDebugging(`generateSessionTitle failed: ${error}`, {
+      level: "error"
+    });
+    logEvent("tengu_session_title_generated", { success: false });
+    return null;
+  }
+}
+var MAX_CONVERSATION_TEXT = 1000, SESSION_TITLE_PROMPT = `Generate a concise, sentence-case title (3-7 words) that captures the main topic or goal of this coding session. The title should be clear enough that the user recognizes the session in a list. Use sentence case: capitalize only the first word and proper nouns.
+
+Return JSON with a single "title" field.
+
+Good examples:
+{"title": "Fix login button on mobile"}
+{"title": "Add OAuth authentication"}
+{"title": "Debug failing CI tests"}
+{"title": "Refactor API client error handling"}
+
+Bad (too vague): {"title": "Code changes"}
+Bad (too long): {"title": "Investigate and fix the issue where the login button does not respond on mobile devices"}
+Bad (wrong case): {"title": "Fix Login Button On Mobile"}`, titleSchema;
+var init_sessionTitle = __esm(() => {
+  init_v4();
+  init_state();
+  init_analytics();
+  init_claude();
+  init_debug();
+  init_json();
+  init_lazySchema();
+  init_messages();
+  init_systemPromptType();
+  titleSchema = lazySchema(() => exports_external.object({ title: exports_external.string() }));
+});
+
+export { extractConversationText, generateSessionTitle, init_sessionTitle };

package/dist/chunk-g2dr9kyp.js

@@ -0,0 +1,90 @@
+// @bun
+import {
+  ToolSearchTool,
+  clearToolSearchDescriptionCache,
+  init_ToolSearchTool,
+  inputSchema,
+  outputSchema
+} from "./chunk-363p49h1.js";
+import"./chunk-14cmss9n.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-2n877dxb.js";
+import"./chunk-cc15x0zt.js";
+import"./chunk-7ke2txc2.js";
+import"./chunk-t0zcygwt.js";
+import"./chunk-dmqarh6q.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-nymbd7tw.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-5ctt9z6m.js";
+import"./chunk-z9w0ffmw.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-4cptw4qa.js";
+import"./chunk-hfzj1m07.js";
+import"./chunk-jxgm95zx.js";
+import"./chunk-nswqqqdd.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-pxjqgrdk.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-7wj3b774.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-w9k8zntt.js";
+import"./chunk-skctedsv.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-vratq94g.js";
+import"./chunk-rvqtbt9h.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-cvge4pvp.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-x14dq3v1.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_ToolSearchTool();
+
+export {
+  outputSchema,
+  inputSchema,
+  clearToolSearchDescriptionCache,
+  ToolSearchTool
+};