@foxclicom/foxcli 2.1.89

package/dist/chunk-e5pntxye.js

@@ -0,0 +1,37 @@
+// @bun
+import {
+  cacheKeys,
+  init_fileStateCache
+} from "./chunk-9gbamk79.js";
+import"./chunk-qnfx3qtx.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/files/files.ts
+import { relative } from "path";
+async function call(_args, context) {
+  const files = context.readFileState ? cacheKeys(context.readFileState) : [];
+  if (files.length === 0) {
+    return { type: "text", value: "No files in context" };
+  }
+  const fileList = files.map((file) => relative(getCwd(), file)).join(`
+`);
+  return { type: "text", value: `Files in context:
+${fileList}` };
+}
+var init_files = __esm(() => {
+  init_cwd();
+  init_fileStateCache();
+});
+init_files();
+
+export {
+  call
+};

package/dist/chunk-e6v9mqg8.js

@@ -0,0 +1,281 @@
+// @bun
+import {
+  analyzeContextUsage,
+  getMessagesAfterCompactBoundary,
+  init_analyzeContext,
+  init_messages1 as init_messages,
+  init_microCompact,
+  microcompactMessages
+} from "./chunk-363p49h1.js";
+import {
+  getSourceDisplayName,
+  init_constants,
+  init_stringUtils
+} from "./chunk-skctedsv.js";
+import {
+  formatTokens,
+  init_format
+} from "./chunk-x14dq3v1.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/context/context-noninteractive.ts
+async function collectContextData(context) {
+  const {
+    messages,
+    getAppState,
+    options: {
+      mainLoopModel,
+      tools,
+      agentDefinitions,
+      customSystemPrompt,
+      appendSystemPrompt
+    }
+  } = context;
+  let apiView = getMessagesAfterCompactBoundary(messages);
+  if (false) {}
+  const { messages: compactedMessages } = await microcompactMessages(apiView);
+  const appState = getAppState();
+  return analyzeContextUsage(compactedMessages, mainLoopModel, async () => appState.toolPermissionContext, tools, agentDefinitions, undefined, { options: { customSystemPrompt, appendSystemPrompt } }, undefined, apiView);
+}
+async function call(_args, context) {
+  const data = await collectContextData(context);
+  return {
+    type: "text",
+    value: formatContextAsMarkdownTable(data)
+  };
+}
+function formatContextAsMarkdownTable(data) {
+  const {
+    categories,
+    totalTokens,
+    rawMaxTokens,
+    percentage,
+    model,
+    memoryFiles,
+    mcpTools,
+    agents,
+    skills,
+    messageBreakdown,
+    systemTools,
+    systemPromptSections
+  } = data;
+  let output = `## Context Usage
+
+`;
+  output += `**Model:** ${model}  
+`;
+  output += `**Tokens:** ${formatTokens(totalTokens)} / ${formatTokens(rawMaxTokens)} (${percentage}%)
+`;
+  if (false) {}
+  output += `
+`;
+  const visibleCategories = categories.filter((cat) => cat.tokens > 0 && cat.name !== "Free space" && cat.name !== "Autocompact buffer");
+  if (visibleCategories.length > 0) {
+    output += `### Estimated usage by category
+
+`;
+    output += `| Category | Tokens | Percentage |
+`;
+    output += `|----------|--------|------------|
+`;
+    for (const cat of visibleCategories) {
+      const percentDisplay = (cat.tokens / rawMaxTokens * 100).toFixed(1);
+      output += `| ${cat.name} | ${formatTokens(cat.tokens)} | ${percentDisplay}% |
+`;
+    }
+    const freeSpaceCategory = categories.find((c) => c.name === "Free space");
+    if (freeSpaceCategory && freeSpaceCategory.tokens > 0) {
+      const percentDisplay = (freeSpaceCategory.tokens / rawMaxTokens * 100).toFixed(1);
+      output += `| Free space | ${formatTokens(freeSpaceCategory.tokens)} | ${percentDisplay}% |
+`;
+    }
+    const autocompactCategory = categories.find((c) => c.name === "Autocompact buffer");
+    if (autocompactCategory && autocompactCategory.tokens > 0) {
+      const percentDisplay = (autocompactCategory.tokens / rawMaxTokens * 100).toFixed(1);
+      output += `| Autocompact buffer | ${formatTokens(autocompactCategory.tokens)} | ${percentDisplay}% |
+`;
+    }
+    output += `
+`;
+  }
+  if (mcpTools.length > 0) {
+    output += `### MCP Tools
+
+`;
+    output += `| Tool | Server | Tokens |
+`;
+    output += `|------|--------|--------|
+`;
+    for (const tool of mcpTools) {
+      output += `| ${tool.name} | ${tool.serverName} | ${formatTokens(tool.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (systemTools && systemTools.length > 0 && process.env.USER_TYPE === "ant") {
+    output += `### [ANT-ONLY] System Tools
+
+`;
+    output += `| Tool | Tokens |
+`;
+    output += `|------|--------|
+`;
+    for (const tool of systemTools) {
+      output += `| ${tool.name} | ${formatTokens(tool.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (systemPromptSections && systemPromptSections.length > 0 && process.env.USER_TYPE === "ant") {
+    output += `### [ANT-ONLY] System Prompt Sections
+
+`;
+    output += `| Section | Tokens |
+`;
+    output += `|---------|--------|
+`;
+    for (const section of systemPromptSections) {
+      output += `| ${section.name} | ${formatTokens(section.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (agents.length > 0) {
+    output += `### Custom Agents
+
+`;
+    output += `| Agent Type | Source | Tokens |
+`;
+    output += `|------------|--------|--------|
+`;
+    for (const agent of agents) {
+      let sourceDisplay;
+      switch (agent.source) {
+        case "projectSettings":
+          sourceDisplay = "Project";
+          break;
+        case "userSettings":
+          sourceDisplay = "User";
+          break;
+        case "localSettings":
+          sourceDisplay = "Local";
+          break;
+        case "flagSettings":
+          sourceDisplay = "Flag";
+          break;
+        case "policySettings":
+          sourceDisplay = "Policy";
+          break;
+        case "plugin":
+          sourceDisplay = "Plugin";
+          break;
+        case "built-in":
+          sourceDisplay = "Built-in";
+          break;
+        default:
+          sourceDisplay = String(agent.source);
+      }
+      output += `| ${agent.agentType} | ${sourceDisplay} | ${formatTokens(agent.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (memoryFiles.length > 0) {
+    output += `### Memory Files
+
+`;
+    output += `| Type | Path | Tokens |
+`;
+    output += `|------|------|--------|
+`;
+    for (const file of memoryFiles) {
+      output += `| ${file.type} | ${file.path} | ${formatTokens(file.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (skills && skills.tokens > 0 && skills.skillFrontmatter.length > 0) {
+    output += `### Skills
+
+`;
+    output += `| Skill | Source | Tokens |
+`;
+    output += `|-------|--------|--------|
+`;
+    for (const skill of skills.skillFrontmatter) {
+      output += `| ${skill.name} | ${getSourceDisplayName(skill.source)} | ${formatTokens(skill.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (messageBreakdown && process.env.USER_TYPE === "ant") {
+    output += `### [ANT-ONLY] Message Breakdown
+
+`;
+    output += `| Category | Tokens |
+`;
+    output += `|----------|--------|
+`;
+    output += `| Tool calls | ${formatTokens(messageBreakdown.toolCallTokens)} |
+`;
+    output += `| Tool results | ${formatTokens(messageBreakdown.toolResultTokens)} |
+`;
+    output += `| Attachments | ${formatTokens(messageBreakdown.attachmentTokens)} |
+`;
+    output += `| Assistant messages (non-tool) | ${formatTokens(messageBreakdown.assistantMessageTokens)} |
+`;
+    output += `| User messages (non-tool-result) | ${formatTokens(messageBreakdown.userMessageTokens)} |
+`;
+    output += `
+`;
+    if (messageBreakdown.toolCallsByType.length > 0) {
+      output += `#### Top Tools
+
+`;
+      output += `| Tool | Call Tokens | Result Tokens |
+`;
+      output += `|------|-------------|---------------|
+`;
+      for (const tool of messageBreakdown.toolCallsByType) {
+        output += `| ${tool.name} | ${formatTokens(tool.callTokens)} | ${formatTokens(tool.resultTokens)} |
+`;
+      }
+      output += `
+`;
+    }
+    if (messageBreakdown.attachmentsByType.length > 0) {
+      output += `#### Top Attachments
+
+`;
+      output += `| Attachment | Tokens |
+`;
+      output += `|------------|--------|
+`;
+      for (const attachment of messageBreakdown.attachmentsByType) {
+        output += `| ${attachment.name} | ${formatTokens(attachment.tokens)} |
+`;
+      }
+      output += `
+`;
+    }
+  }
+  return output;
+}
+var init_context_noninteractive = __esm(() => {
+  init_microCompact();
+  init_analyzeContext();
+  init_format();
+  init_messages();
+  init_constants();
+  init_stringUtils();
+});
+
+export { collectContextData, call, init_context_noninteractive };

package/dist/chunk-e7393td6.js

@@ -0,0 +1,42 @@
+// @bun
+import {
+  init_browser,
+  openBrowser
+} from "./chunk-m06q12hg.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 {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/stickers/stickers.ts
+async function call() {
+  const url = "https://www.stickermule.com/claudecode";
+  const success = await openBrowser(url);
+  if (success) {
+    return { type: "text", value: "Opening sticker page in browser\u2026" };
+  } else {
+    return {
+      type: "text",
+      value: `Failed to open browser. Visit: ${url}`
+    };
+  }
+}
+var init_stickers = __esm(() => {
+  init_browser();
+});
+init_stickers();
+
+export {
+  call
+};

package/dist/chunk-ef8r68ej.js

@@ -0,0 +1,120 @@
+// @bun
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  init_file,
+  pathExists,
+  saveGlobalConfig
+} from "./chunk-skctedsv.js";
+import {
+  detectCurrentRepository,
+  init_detectRepository,
+  parseGitHubRepository
+} from "./chunk-7z8j9qfn.js";
+import {
+  findGitRoot,
+  getRemoteUrlForDir,
+  init_git,
+  init_gitFilesystem
+} from "./chunk-hrzerbfw.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  getOriginalCwd,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+
+// src/utils/githubRepoPathMapping.ts
+init_state();
+init_config();
+init_debug();
+init_detectRepository();
+init_file();
+init_gitFilesystem();
+init_git();
+import { realpath } from "fs/promises";
+async function updateGithubRepoPathMapping() {
+  try {
+    const repo = await detectCurrentRepository();
+    if (!repo) {
+      logForDebugging("Not in a GitHub repository, skipping path mapping update");
+      return;
+    }
+    const cwd = getOriginalCwd();
+    const gitRoot = findGitRoot(cwd);
+    const basePath = gitRoot ?? cwd;
+    let currentPath;
+    try {
+      currentPath = (await realpath(basePath)).normalize("NFC");
+    } catch {
+      currentPath = basePath;
+    }
+    const repoKey = repo.toLowerCase();
+    const config = getGlobalConfig();
+    const existingPaths = config.githubRepoPaths?.[repoKey] ?? [];
+    if (existingPaths[0] === currentPath) {
+      logForDebugging(`Path ${currentPath} already tracked for repo ${repoKey}`);
+      return;
+    }
+    const withoutCurrent = existingPaths.filter((p) => p !== currentPath);
+    const updatedPaths = [currentPath, ...withoutCurrent];
+    saveGlobalConfig((current) => ({
+      ...current,
+      githubRepoPaths: {
+        ...current.githubRepoPaths,
+        [repoKey]: updatedPaths
+      }
+    }));
+    logForDebugging(`Added ${currentPath} to tracked paths for repo ${repoKey}`);
+  } catch (error) {
+    logForDebugging(`Error updating repo path mapping: ${error}`);
+  }
+}
+function getKnownPathsForRepo(repo) {
+  const config = getGlobalConfig();
+  const repoKey = repo.toLowerCase();
+  return config.githubRepoPaths?.[repoKey] ?? [];
+}
+async function filterExistingPaths(paths) {
+  const results = await Promise.all(paths.map(pathExists));
+  return paths.filter((_, i) => results[i]);
+}
+async function validateRepoAtPath(path, expectedRepo) {
+  try {
+    const remoteUrl = await getRemoteUrlForDir(path);
+    if (!remoteUrl) {
+      return false;
+    }
+    const actualRepo = parseGitHubRepository(remoteUrl);
+    if (!actualRepo) {
+      return false;
+    }
+    return actualRepo.toLowerCase() === expectedRepo.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function removePathFromRepo(repo, pathToRemove) {
+  const config = getGlobalConfig();
+  const repoKey = repo.toLowerCase();
+  const existingPaths = config.githubRepoPaths?.[repoKey] ?? [];
+  const updatedPaths = existingPaths.filter((path) => path !== pathToRemove);
+  if (updatedPaths.length === existingPaths.length) {
+    return;
+  }
+  const updatedMapping = { ...config.githubRepoPaths };
+  if (updatedPaths.length === 0) {
+    delete updatedMapping[repoKey];
+  } else {
+    updatedMapping[repoKey] = updatedPaths;
+  }
+  saveGlobalConfig((current) => ({
+    ...current,
+    githubRepoPaths: updatedMapping
+  }));
+  logForDebugging(`Removed ${pathToRemove} from tracked paths for repo ${repoKey}`);
+}
+
+export { updateGithubRepoPathMapping, getKnownPathsForRepo, filterExistingPaths, validateRepoAtPath, removePathFromRepo };