@shareai-lab/kode 2.0.1 → 2.0.3

package/dist/chunks/chunk-3OEJVB5A.js

@@ -0,0 +1,906 @@
+import {
+  getCwd
+} from "./chunk-BBJFHTBC.js";
+import {
+  PLAN_SLUG_ADJECTIVES,
+  PLAN_SLUG_NOUNS,
+  PLAN_SLUG_VERBS
+} from "./chunk-QHQOBUF6.js";
+import {
+  MACRO
+} from "./chunk-W5EGGA44.js";
+
+// packages/core/src/utils/execFileNoThrow.ts
+import { execFile } from "child_process";
+
+// packages/core/src/logging/log/paths.ts
+import { existsSync } from "fs";
+import { randomUUID } from "crypto";
+import { join } from "path";
+import envPaths from "env-paths";
+
+// packages/core/src/constants/product.ts
+var PRODUCT_NAME = "Kode";
+var PROJECT_FILE = "AGENTS.md";
+var PRODUCT_COMMAND = "kode";
+var CONFIG_BASE_DIR = ".kode";
+var CONFIG_FILE = ".kode.json";
+var GITHUB_ISSUES_REPO_URL = "https://github.com/shareAI-lab/Anykode/issues";
+var ASCII_LOGO = `
+ _  __         _        ____ _     ___
+| |/ /___   __| | ___  / ___| |   |_ _|
+| ' // _ \\ / _\` |/ _ \\| |   | |    | |
+| . \\ (_) | (_| |  __/| |___| |___ | |
+|_|\\_\\___/ \\__,_|\\___| \\____|_____|___|`;
+
+// packages/core/src/logging/log/paths.ts
+var SESSION_ID = randomUUID();
+var paths = envPaths(PRODUCT_COMMAND);
+function getProjectDir(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function getLegacyCacheRoot() {
+  return process.env.KODE_LEGACY_CACHE_ROOT ?? paths.cache;
+}
+function getNewLogRoot() {
+  return process.env.KODE_LOG_ROOT ?? getKodeBaseDir();
+}
+var CACHE_PATHS = {
+  errors: () => join(getNewLogRoot(), getProjectDir(process.cwd()), "errors"),
+  messages: () => join(getNewLogRoot(), getProjectDir(process.cwd()), "messages"),
+  mcpLogs: (serverName) => join(
+    getLegacyCacheRoot(),
+    getProjectDir(process.cwd()),
+    `mcp-logs-${serverName}`
+  )
+};
+var LEGACY_CACHE_PATHS = {
+  errors: () => join(getLegacyCacheRoot(), getProjectDir(process.cwd()), "errors"),
+  messages: () => join(getLegacyCacheRoot(), getProjectDir(process.cwd()), "messages"),
+  mcpLogs: (serverName) => join(
+    getLegacyCacheRoot(),
+    getProjectDir(process.cwd()),
+    `mcp-logs-${serverName}`
+  )
+};
+function dateToFilename(date) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+var DATE = dateToFilename(/* @__PURE__ */ new Date());
+function getErrorsPath() {
+  return join(CACHE_PATHS.errors(), DATE + ".txt");
+}
+function getMessagesPath(messageLogName, forkNumber, sidechainNumber) {
+  return join(
+    CACHE_PATHS.messages(),
+    `${messageLogName}${forkNumber > 0 ? `-${forkNumber}` : ""}${sidechainNumber > 0 ? `-sidechain-${sidechainNumber}` : ""}.json`
+  );
+}
+function parseLogFilename(filename) {
+  const base = filename.split(".")[0];
+  const segments = base.split("-");
+  const hasSidechain = base.includes("-sidechain-");
+  let date = base;
+  let forkNumber = void 0;
+  let sidechainNumber = void 0;
+  if (hasSidechain) {
+    const sidechainIndex = segments.indexOf("sidechain");
+    sidechainNumber = Number(segments[sidechainIndex + 1]);
+    if (sidechainIndex > 6) {
+      forkNumber = Number(segments[sidechainIndex - 1]);
+      date = segments.slice(0, 6).join("-");
+    } else {
+      date = segments.slice(0, 6).join("-");
+    }
+  } else if (segments.length > 6) {
+    const lastSegment = Number(segments[segments.length - 1]);
+    forkNumber = lastSegment >= 0 ? lastSegment : void 0;
+    date = segments.slice(0, 6).join("-");
+  } else {
+    date = base;
+  }
+  return { date, forkNumber, sidechainNumber };
+}
+function getNextAvailableLogForkNumber(date, forkNumber, sidechainNumber) {
+  while (existsSync(getMessagesPath(date, forkNumber, sidechainNumber))) {
+    forkNumber++;
+  }
+  return forkNumber;
+}
+function getNextAvailableLogSidechainNumber(date, forkNumber) {
+  let sidechainNumber = 1;
+  while (existsSync(getMessagesPath(date, forkNumber, sidechainNumber))) {
+    sidechainNumber++;
+  }
+  return sidechainNumber;
+}
+
+// packages/core/src/logging/log/errors.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
+import { join as join2 } from "path";
+
+// packages/core/src/logging/log/jsonLog.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { dirname } from "path";
+
+// packages/core/src/logging/log/filesystem.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+var PERMISSION_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EPERM", "EROFS"]);
+function isPermissionError(error) {
+  return typeof error === "object" && error !== null && "code" in error && PERMISSION_ERROR_CODES.has(error.code ?? "");
+}
+function safeMkdir(dir) {
+  if (existsSync2(dir)) return true;
+  try {
+    mkdirSync(dir, { recursive: true });
+    return true;
+  } catch (error) {
+    if (isPermissionError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function safeWriteFile(path, data, encoding = "utf8") {
+  try {
+    writeFileSync(path, data, encoding);
+    return true;
+  } catch (error) {
+    if (isPermissionError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+// packages/core/src/logging/log/jsonLog.ts
+function readJsonLog(path) {
+  if (!existsSync3(path)) {
+    return [];
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function appendToJsonLog(path, message) {
+  if (process.env.USER_TYPE === "external") {
+    return;
+  }
+  const dir = dirname(path);
+  if (!safeMkdir(dir)) {
+    return;
+  }
+  if (!existsSync3(path) && !safeWriteFile(path, "[]")) {
+    return;
+  }
+  const messages = readJsonLog(path);
+  const messageWithTimestamp = {
+    ...message,
+    cwd: process.cwd(),
+    userType: process.env.USER_TYPE,
+    sessionId: SESSION_ID,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    version: MACRO.VERSION
+  };
+  messages.push(messageWithTimestamp);
+  safeWriteFile(path, JSON.stringify(messages, null, 2));
+}
+
+// packages/core/src/logging/log/errors.ts
+var IN_MEMORY_ERROR_LOG = [];
+var MAX_IN_MEMORY_ERRORS = 100;
+function logError(error) {
+  try {
+    if (process.env.NODE_ENV === "test") {
+      console.error(error);
+    }
+    const errorStr = error instanceof Error ? error.stack || error.message : String(error);
+    const errorInfo = {
+      error: errorStr,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (IN_MEMORY_ERROR_LOG.length >= MAX_IN_MEMORY_ERRORS) {
+      IN_MEMORY_ERROR_LOG.shift();
+    }
+    IN_MEMORY_ERROR_LOG.push(errorInfo);
+    appendToJsonLog(getErrorsPath(), {
+      error: errorStr
+    });
+  } catch {
+  }
+}
+function logMCPError(serverName, error) {
+  try {
+    const logDir = CACHE_PATHS.mcpLogs(serverName);
+    const errorStr = error instanceof Error ? error.stack || error.message : String(error);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logFile = join2(logDir, DATE + ".txt");
+    if (!existsSync4(logDir)) {
+      mkdirSync2(logDir, { recursive: true });
+    }
+    if (!existsSync4(logFile)) {
+      writeFileSync2(logFile, "[]", "utf8");
+    }
+    const errorInfo = {
+      error: errorStr,
+      timestamp,
+      sessionId: SESSION_ID,
+      cwd: process.cwd()
+    };
+    const messages = readJsonLog(logFile);
+    messages.push(errorInfo);
+    writeFileSync2(logFile, JSON.stringify(messages, null, 2), "utf8");
+  } catch {
+  }
+}
+
+// packages/core/src/logging/log/messages.ts
+import { dirname as dirname2 } from "path";
+
+// packages/core/src/plan/mode/paths.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync2, realpathSync } from "fs";
+import { isAbsolute, join as join3, relative, resolve, parse as parse2 } from "path";
+
+// packages/core/src/plan/mode/slug.ts
+import { randomBytes } from "crypto";
+import { parse } from "path";
+
+// packages/core/src/plan/mode/state.ts
+var DEFAULT_CONVERSATION_KEY = "default";
+var planModeEnabledByConversationKey = /* @__PURE__ */ new Map();
+var planModeFlagsByConversationKey = /* @__PURE__ */ new Map();
+var planModeAttachmentStateByAgentKey = /* @__PURE__ */ new Map();
+var activePlanConversationKey = null;
+function getConversationKey(context) {
+  const messageLogName = context?.options?.messageLogName ?? DEFAULT_CONVERSATION_KEY;
+  const forkNumber = context?.options?.forkNumber ?? 0;
+  return `${messageLogName}:${forkNumber}`;
+}
+function getPlanConversationKey(context) {
+  return getConversationKey(context);
+}
+function setActivePlanConversationKey(conversationKey) {
+  activePlanConversationKey = conversationKey;
+}
+function getActivePlanConversationKey() {
+  return activePlanConversationKey;
+}
+function getAgentKey(context) {
+  const conversationKey = getConversationKey(context);
+  const agentId = context?.agentId ?? "main";
+  return `${conversationKey}:${agentId}`;
+}
+function isPlanModeEnabled(context) {
+  const key = getConversationKey(context);
+  return planModeEnabledByConversationKey.get(key) ?? false;
+}
+function setPlanModeEnabledForConversationKey(conversationKey, enabled) {
+  planModeEnabledByConversationKey.set(conversationKey, enabled);
+}
+function getPlanModeFlags(conversationKey) {
+  const existing = planModeFlagsByConversationKey.get(conversationKey);
+  if (existing) return existing;
+  const created = {
+    hasExitedPlanMode: false,
+    needsPlanModeExitAttachment: false
+  };
+  planModeFlagsByConversationKey.set(conversationKey, created);
+  return created;
+}
+function getPlanModeAttachmentState(agentKey) {
+  return planModeAttachmentStateByAgentKey.get(agentKey);
+}
+function setPlanModeAttachmentState(agentKey, state) {
+  planModeAttachmentStateByAgentKey.set(agentKey, state);
+}
+
+// packages/core/src/plan/mode/slug.ts
+var planSlugCache = /* @__PURE__ */ new Map();
+function pickIndex(length) {
+  return randomBytes(4).readUInt32BE(0) % length;
+}
+function pickWord(words) {
+  return words[pickIndex(words.length)];
+}
+function generateSlug() {
+  const adjective = pickWord(PLAN_SLUG_ADJECTIVES);
+  const verb = pickWord(PLAN_SLUG_VERBS);
+  const noun = pickWord(PLAN_SLUG_NOUNS);
+  return `${adjective}-${verb}-${noun}`;
+}
+function setPlanSlug(conversationKey, slug) {
+  planSlugCache.set(conversationKey, slug);
+}
+function getPlanSlugForConversationKey(conversationKey) {
+  return planSlugCache.get(conversationKey) ?? null;
+}
+function extractSlugFromPlanFilePath(planFilePath) {
+  if (!planFilePath) return null;
+  const baseName = parse(planFilePath).name;
+  if (!baseName) return null;
+  const agentMarker = "-agent-";
+  const idx = baseName.lastIndexOf(agentMarker);
+  if (idx === -1) return baseName;
+  if (idx === 0) return null;
+  return baseName.slice(0, idx);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function getTrimmedString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function hydratePlanSlugFromMessages(messages, context) {
+  const conversationKey = getConversationKey(context);
+  if (planSlugCache.has(conversationKey)) return true;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!isRecord(msg)) continue;
+    const directSlug = getTrimmedString(msg.slug);
+    if (directSlug) {
+      planSlugCache.set(conversationKey, directSlug);
+      return true;
+    }
+    const toolUseResult = msg.toolUseResult;
+    if (!isRecord(toolUseResult)) continue;
+    const data = toolUseResult.data;
+    if (!isRecord(data)) continue;
+    const planFilePath = getTrimmedString(data.planFilePath) || getTrimmedString(data.filePath);
+    if (!planFilePath) continue;
+    const slug = extractSlugFromPlanFilePath(planFilePath);
+    if (!slug) continue;
+    planSlugCache.set(conversationKey, slug);
+    return true;
+  }
+  return false;
+}
+
+// packages/core/src/plan/mode/paths.ts
+var MAX_SLUG_ATTEMPTS = 10;
+function getPlanDirectory() {
+  const dir = join3(getKodeBaseDir(), "plans");
+  if (!existsSync5(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  return dir;
+}
+function getOrCreatePlanSlug(conversationKey) {
+  const existing = getPlanSlugForConversationKey(conversationKey);
+  if (existing) return existing;
+  const dir = getPlanDirectory();
+  let slug = null;
+  for (let attempt = 0; attempt < MAX_SLUG_ATTEMPTS; attempt++) {
+    slug = generateSlug();
+    const path = join3(dir, `${slug}.md`);
+    if (!existsSync5(path)) break;
+  }
+  if (!slug) slug = generateSlug();
+  setPlanSlug(conversationKey, slug);
+  return slug;
+}
+function getPlanFilePath(agentId, conversationKey) {
+  const dir = getPlanDirectory();
+  const key = conversationKey ?? DEFAULT_CONVERSATION_KEY;
+  const slug = getOrCreatePlanSlug(key);
+  if (!agentId) return join3(dir, `${slug}.md`);
+  return join3(dir, `${slug}-agent-${agentId}.md`);
+}
+function resolveExistingPath(path) {
+  const resolved = resolve(path);
+  try {
+    return realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function isMainPlanFilePathForActiveConversation(path) {
+  const key = getActivePlanConversationKey() ?? DEFAULT_CONVERSATION_KEY;
+  const expected = resolveExistingPath(getPlanFilePath(void 0, key));
+  const target = resolveExistingPath(path);
+  return target === expected;
+}
+function readPlanFile(agentId, conversationKey) {
+  const planFilePath = getPlanFilePath(agentId, conversationKey);
+  if (!existsSync5(planFilePath)) {
+    return { content: "", exists: false, planFilePath };
+  }
+  return {
+    content: readFileSync2(planFilePath, "utf8"),
+    exists: true,
+    planFilePath
+  };
+}
+
+// packages/core/src/plan/mode/systemPrompt.ts
+import { existsSync as existsSync6 } from "fs";
+
+// packages/core/src/plan/mode/reminders.ts
+function getMaxParallelExploreAgents() {
+  const raw = process.env.KODE_PLAN_V2_EXPLORE_AGENT_COUNT ?? process.env.CLAUDE_CODE_PLAN_V2_EXPLORE_AGENT_COUNT;
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed > 0 && parsed <= 10) return parsed;
+  }
+  return 3;
+}
+function getMaxParallelPlanAgents() {
+  const raw = process.env.KODE_PLAN_V2_AGENT_COUNT ?? process.env.CLAUDE_CODE_PLAN_V2_AGENT_COUNT;
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed > 0 && parsed <= 10) return parsed;
+  }
+  return 1;
+}
+function buildPlanModeMainReminder(args) {
+  const { planExists, planFilePath } = args;
+  const writeToolName = "Write";
+  const editToolName = "Edit";
+  const askUserToolName = "AskUserQuestion";
+  const exploreAgentType = "Explore";
+  const planAgentType = "Plan";
+  const exitPlanModeToolName = "ExitPlanMode";
+  const maxParallelExploreAgents = getMaxParallelExploreAgents();
+  const maxParallelPlanAgents = getMaxParallelPlanAgents();
+  return `Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received.
+
+## Plan File Info:
+${planExists ? `A plan file already exists at ${planFilePath}. You can read it and make incremental edits using the ${editToolName} tool.` : `No plan file exists yet. You should create your plan at ${planFilePath} using the ${writeToolName} tool.`}
+You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit - other than this you are only allowed to take READ-ONLY actions.
+
+## Plan Workflow
+
+### Phase 1: Initial Understanding
+Goal: Gain a comprehensive understanding of the user's request by reading through code and asking them questions. Critical: In this phase you should only use the ${exploreAgentType} subagent type.
+
+1. Focus on understanding the user's request and the code associated with their request
+
+2. **Launch up to ${maxParallelExploreAgents} ${exploreAgentType} agents IN PARALLEL** (single message, multiple tool calls) to efficiently explore the codebase.
+   - Use 1 agent when the task is isolated to known files, the user provided specific file paths, or you're making a small targeted change.
+   - Use multiple agents when: the scope is uncertain, multiple areas of the codebase are involved, or you need to understand existing patterns before planning.
+   - Quality over quantity - ${maxParallelExploreAgents} agents maximum, but you should try to use the minimum number of agents necessary (usually just 1)
+   - If using multiple agents: Provide each agent with a specific search focus or area to explore. Example: One agent searches for existing implementations, another explores related components, a third investigates testing patterns
+
+3. After exploring the code, use the ${askUserToolName} tool to clarify ambiguities in the user request up front.
+
+### Phase 2: Design
+Goal: Design an implementation approach.
+
+Launch ${planAgentType} agent(s) to design the implementation based on the user's intent and your exploration results from Phase 1.
+
+You can launch up to ${maxParallelPlanAgents} agent(s) in parallel.
+
+**Guidelines:**
+- **Default**: Launch at least 1 Plan agent for most tasks - it helps validate your understanding and consider alternatives
+- **Skip agents**: Only for truly trivial tasks (typo fixes, single-line changes, simple renames)
+${maxParallelPlanAgents > 1 ? `- **Multiple agents**: Use up to ${maxParallelPlanAgents} agents for complex tasks that benefit from different perspectives
+
+Examples of when to use multiple agents:
+- The task touches multiple parts of the codebase
+- It's a large refactor or architectural change
+- There are many edge cases to consider
+- You'd benefit from exploring different approaches
+
+Example perspectives by task type:
+- New feature: simplicity vs performance vs maintainability
+- Bug fix: root cause vs workaround vs prevention
+- Refactoring: minimal change vs clean architecture
+` : ""}
+In the agent prompt:
+- Provide comprehensive background context from Phase 1 exploration including filenames and code path traces
+- Describe requirements and constraints
+- Request a detailed implementation plan
+
+### Phase 3: Review
+Goal: Review the plan(s) from Phase 2 and ensure alignment with the user's intentions.
+1. Read the critical files identified by agents to deepen your understanding
+2. Ensure that the plans align with the user's original request
+3. Use ${askUserToolName} to clarify any remaining questions with the user
+
+### Phase 4: Final Plan
+Goal: Write your final plan to the plan file (the only file you can edit).
+- Include only your recommended approach, not all alternatives
+- Ensure that the plan file is concise enough to scan quickly, but detailed enough to execute effectively
+- Include the paths of critical files to be modified
+
+### Phase 5: Call ${exitPlanModeToolName}
+At the very end of your turn, once you have asked the user questions and are happy with your final plan file - you should always call ${exitPlanModeToolName} to indicate to the user that you are done planning.
+This is critical - your turn should only end with either asking the user a question or calling ${exitPlanModeToolName}. Do not stop unless it's for these 2 reasons.
+
+NOTE: At any point in time through this workflow you should feel free to ask the user questions or clarifications. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.`;
+}
+function buildPlanModeSubAgentReminder(args) {
+  const { planExists, planFilePath } = args;
+  const writeToolName = "Write";
+  const editToolName = "Edit";
+  const askUserToolName = "AskUserQuestion";
+  return `Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received (for example, to make edits). Instead, you should:
+
+## Plan File Info:
+${planExists ? `A plan file already exists at ${planFilePath}. You can read it and make incremental edits using the ${editToolName} tool if you need to.` : `No plan file exists yet. You should create your plan at ${planFilePath} using the ${writeToolName} tool if you need to.`}
+You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit - other than this you are only allowed to take READ-ONLY actions.
+Answer the user's query comprehensively, using the ${askUserToolName} tool if you need to ask the user clarifying questions. If you do use the ${askUserToolName}, make sure to ask all clarifying questions you need to fully understand the user's intent before proceeding.`;
+}
+function buildPlanModeReentryReminder(planFilePath) {
+  const exitPlanModeToolName = "ExitPlanMode";
+  return `## Re-entering Plan Mode
+
+You are returning to plan mode after having previously exited it. A plan file exists at ${planFilePath} from your previous planning session.
+
+**Before proceeding with any new planning, you should:**
+1. Read the existing plan file to understand what was previously planned
+2. Evaluate the user's current request against that plan
+3. Decide how to proceed:
+   - **Different task**: If the user's request is for a different task\u2014even if it's similar or related\u2014start fresh by overwriting the existing plan
+   - **Same task, continuing**: If this is explicitly a continuation or refinement of the exact same task, modify the existing plan while cleaning up outdated or irrelevant sections
+4. Continue on with the plan process and most importantly you should always edit the plan file one way or the other before calling ${exitPlanModeToolName}
+
+Treat this as a fresh planning session. Do not assume the existing plan is relevant without evaluating it first.`;
+}
+function buildPlanModeExitReminder(planFilePath) {
+  return `## Exited Plan Mode
+
+You have exited plan mode. You can now make edits, run tools, and take actions. The plan file is located at ${planFilePath} if you need to reference it.`;
+}
+function wrapSystemReminder(text) {
+  return `<system-reminder>
+${text}
+</system-reminder>`;
+}
+
+// packages/core/src/plan/mode/systemPrompt.ts
+var TURNS_BETWEEN_ATTACHMENTS = 5;
+function getPlanModeSystemPromptAdditions(messages, context) {
+  const conversationKey = getConversationKey(context);
+  const agentKey = getAgentKey(context);
+  const flags = getPlanModeFlags(conversationKey);
+  const additions = [];
+  const assistantTurns = messages.filter((m) => m?.type === "assistant").length;
+  if (isPlanModeEnabled(context)) {
+    const previous = getPlanModeAttachmentState(agentKey) ?? {
+      hasInjected: false,
+      lastInjectedAssistantTurn: -Infinity
+    };
+    if (previous.hasInjected && assistantTurns - previous.lastInjectedAssistantTurn < TURNS_BETWEEN_ATTACHMENTS) {
+      return [];
+    }
+    const planFilePath = getPlanFilePath(context.agentId, conversationKey);
+    const planExists = existsSync6(planFilePath);
+    if (flags.hasExitedPlanMode && planExists) {
+      additions.push(
+        wrapSystemReminder(buildPlanModeReentryReminder(planFilePath))
+      );
+      flags.hasExitedPlanMode = false;
+    }
+    const isSubAgent = !!context.agentId;
+    additions.push(
+      wrapSystemReminder(
+        isSubAgent ? buildPlanModeSubAgentReminder({ planExists, planFilePath }) : buildPlanModeMainReminder({ planExists, planFilePath })
+      )
+    );
+    setPlanModeAttachmentState(agentKey, {
+      hasInjected: true,
+      lastInjectedAssistantTurn: assistantTurns
+    });
+    return additions;
+  }
+  if (flags.needsPlanModeExitAttachment) {
+    const planFilePath = getPlanFilePath(context.agentId, conversationKey);
+    additions.push(wrapSystemReminder(buildPlanModeExitReminder(planFilePath)));
+    flags.needsPlanModeExitAttachment = false;
+  }
+  return additions;
+}
+
+// packages/core/src/plan/mode.ts
+function enterPlanMode(context) {
+  const key = getConversationKey(context);
+  setPlanModeEnabledForConversationKey(key, true);
+  return { planFilePath: getPlanFilePath(context?.agentId, key) };
+}
+function enterPlanModeForConversationKey(conversationKey) {
+  setPlanModeEnabledForConversationKey(conversationKey, true);
+}
+function exitPlanModeForConversationKey(conversationKey) {
+  setPlanModeEnabledForConversationKey(conversationKey, false);
+  const flags = getPlanModeFlags(conversationKey);
+  flags.hasExitedPlanMode = true;
+  flags.needsPlanModeExitAttachment = true;
+}
+
+// packages/core/src/logging/log/messages.ts
+function overwriteLog(path, messages, options) {
+  if (process.env.USER_TYPE === "external") {
+    return;
+  }
+  if (!messages.length) {
+    return;
+  }
+  const dir = dirname2(path);
+  if (!safeMkdir(dir)) {
+    return;
+  }
+  const slug = options?.conversationKey ? getPlanSlugForConversationKey(options.conversationKey) : null;
+  const messagesWithMetadata = messages.map((message) => ({
+    ...message,
+    ...slug ? { slug } : {},
+    cwd: process.cwd(),
+    userType: process.env.USER_TYPE,
+    sessionId: SESSION_ID,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    version: MACRO.VERSION
+  }));
+  safeWriteFile(path, JSON.stringify(messagesWithMetadata, null, 2));
+}
+
+// packages/core/src/logging/log/loadLogList.ts
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync3,
+  readdirSync,
+  statSync,
+  copyFileSync,
+  promises as fsPromises
+} from "fs";
+import { join as join4 } from "path";
+
+// packages/core/src/logging/log/util.ts
+function sortLogs(logs) {
+  return logs.sort((a, b) => {
+    const modifiedDiff = b.modified.getTime() - a.modified.getTime();
+    if (modifiedDiff !== 0) {
+      return modifiedDiff;
+    }
+    const createdDiff = b.created.getTime() - a.created.getTime();
+    if (createdDiff !== 0) {
+      return createdDiff;
+    }
+    return (b.forkNumber ?? 0) - (a.forkNumber ?? 0);
+  });
+}
+function formatDate(date) {
+  const now = /* @__PURE__ */ new Date();
+  const yesterday = new Date(now);
+  yesterday.setDate(yesterday.getDate() - 1);
+  const isToday = date.toDateString() === now.toDateString();
+  const isYesterday = date.toDateString() === yesterday.toDateString();
+  const timeStr = date.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  }).toLowerCase();
+  if (isToday) {
+    return `Today at ${timeStr}`;
+  } else if (isYesterday) {
+    return `Yesterday at ${timeStr}`;
+  } else {
+    return date.toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric"
+    }) + ` at ${timeStr}`;
+  }
+}
+function parseISOString(s) {
+  const b = s.split(/\D+/);
+  return new Date(
+    Date.UTC(
+      parseInt(b[0], 10),
+      parseInt(b[1], 10) - 1,
+      parseInt(b[2], 10),
+      parseInt(b[3], 10),
+      parseInt(b[4], 10),
+      parseInt(b[5], 10),
+      parseInt(b[6], 10)
+    )
+  );
+}
+
+// packages/core/src/logging/log/loadLogList.ts
+var MIGRATION_MESSAGE_LOG_LIMIT = 50;
+var didMigrateMessageLogs = false;
+function migrateLegacyMessageLogsIfNeeded() {
+  if (didMigrateMessageLogs) return;
+  didMigrateMessageLogs = true;
+  const legacyDir = LEGACY_CACHE_PATHS.messages();
+  const newDir = CACHE_PATHS.messages();
+  if (!existsSync7(legacyDir)) return;
+  const newHasAny = existsSync7(newDir) && readdirSync(newDir).some((file) => file.endsWith(".json"));
+  if (newHasAny) return;
+  try {
+    mkdirSync4(newDir, { recursive: true });
+  } catch {
+    return;
+  }
+  let legacyFiles = [];
+  try {
+    legacyFiles = readdirSync(legacyDir).filter((file) => file.endsWith(".json"));
+  } catch {
+    return;
+  }
+  const sorted = legacyFiles.map((file) => {
+    try {
+      const stats = statSync(join4(legacyDir, file));
+      return { file, mtimeMs: stats.mtimeMs };
+    } catch {
+      return { file, mtimeMs: 0 };
+    }
+  }).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MIGRATION_MESSAGE_LOG_LIMIT);
+  for (const { file } of sorted) {
+    const src = join4(legacyDir, file);
+    const dest = join4(newDir, file);
+    if (existsSync7(dest)) continue;
+    try {
+      copyFileSync(src, dest);
+    } catch {
+    }
+  }
+}
+async function loadLogList(path = CACHE_PATHS.messages()) {
+  if (path === CACHE_PATHS.messages()) {
+    migrateLegacyMessageLogsIfNeeded();
+  }
+  const searchPaths = path === CACHE_PATHS.messages() ? [CACHE_PATHS.messages(), LEGACY_CACHE_PATHS.messages()] : [path];
+  const existingPaths = searchPaths.filter((p) => existsSync7(p));
+  if (existingPaths.length === 0) {
+    logError(`No logs found at ${path}`);
+    return [];
+  }
+  const filesWithDir = (await Promise.all(
+    existingPaths.map(async (dirPath) => {
+      const dirFiles = await fsPromises.readdir(dirPath);
+      return dirFiles.map((file) => ({ file, dirPath }));
+    })
+  )).flat();
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueFiles = filesWithDir.filter(({ file }) => {
+    if (seen.has(file)) return false;
+    seen.add(file);
+    return true;
+  });
+  const logData = await Promise.all(
+    uniqueFiles.map(async ({ file, dirPath }, i) => {
+      const fullPath = join4(dirPath, file);
+      const content = readFileSync3(fullPath, "utf8");
+      const messages = JSON.parse(content);
+      const firstMessage = messages[0];
+      const lastMessage = messages[messages.length - 1];
+      const firstPrompt = firstMessage?.type === "user" && typeof firstMessage?.message?.content === "string" ? firstMessage?.message?.content : "No prompt";
+      const { date, forkNumber, sidechainNumber } = parseLogFilename(file);
+      return {
+        date,
+        forkNumber,
+        fullPath,
+        messages,
+        value: i,
+        // overwritten after sorting
+        created: parseISOString(firstMessage?.timestamp || date),
+        modified: lastMessage?.timestamp ? parseISOString(lastMessage.timestamp) : parseISOString(date),
+        firstPrompt: firstPrompt.split("\n")[0]?.slice(0, 50) + (firstPrompt.length > 50 ? "\u2026" : "") || "No prompt",
+        messageCount: messages.length,
+        sidechainNumber
+      };
+    })
+  );
+  return sortLogs(logData.filter((_) => _.messages.length)).map((_, i) => ({
+    ..._,
+    value: i
+  }));
+}
+
+// packages/core/src/utils/execFileNoThrow.ts
+var MS_IN_SECOND = 1e3;
+var SECONDS_IN_MINUTE = 60;
+function execFileNoThrow(file, args, abortSignal, timeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND, preserveOutputOnError = true) {
+  return new Promise((resolve2) => {
+    try {
+      execFile(
+        file,
+        args,
+        {
+          maxBuffer: 1e6,
+          signal: abortSignal,
+          timeout,
+          cwd: getCwd()
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            if (preserveOutputOnError) {
+              const errorCode = typeof error.code === "number" ? error.code : 1;
+              resolve2({
+                stdout: stdout || "",
+                stderr: stderr || "",
+                code: errorCode
+              });
+            } else {
+              resolve2({ stdout: "", stderr: "", code: 1 });
+            }
+          } else {
+            resolve2({ stdout, stderr, code: 0 });
+          }
+        }
+      );
+    } catch (error) {
+      logError(error);
+      resolve2({ stdout: "", stderr: "", code: 1 });
+    }
+  });
+}
+
+// packages/core/src/utils/env.ts
+import { memoize } from "lodash-es";
+import { join as join5 } from "path";
+import { homedir } from "os";
+function getKodeBaseDir() {
+  return process.env.KODE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? join5(homedir(), CONFIG_BASE_DIR);
+}
+function getGlobalConfigFilePath() {
+  return process.env.KODE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR ? join5(getKodeBaseDir(), "config.json") : join5(homedir(), CONFIG_FILE);
+}
+function getMemoryDir() {
+  return join5(getKodeBaseDir(), "memory");
+}
+var KODE_BASE_DIR = getKodeBaseDir();
+var GLOBAL_CONFIG_FILE = getGlobalConfigFilePath();
+var MEMORY_DIR = getMemoryDir();
+var getIsDocker = memoize(async () => {
+  const { code } = await execFileNoThrow("test", ["-f", "/.dockerenv"]);
+  if (code !== 0) {
+    return false;
+  }
+  return process.platform === "linux";
+});
+var hasInternetAccess = memoize(async () => {
+  const offline = process.env.KODE_OFFLINE ?? process.env.OFFLINE ?? process.env.NO_NETWORK ?? "";
+  const normalized = String(offline).trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return false;
+  return true;
+});
+var env = {
+  getIsDocker,
+  hasInternetAccess,
+  isCI: Boolean(process.env.CI),
+  platform: process.platform === "win32" ? "windows" : process.platform === "darwin" ? "macos" : "linux",
+  nodeVersion: process.version,
+  terminal: process.env.TERM_PROGRAM
+};
+
+export {
+  getPlanConversationKey,
+  setActivePlanConversationKey,
+  hydratePlanSlugFromMessages,
+  PRODUCT_NAME,
+  PROJECT_FILE,
+  PRODUCT_COMMAND,
+  CONFIG_BASE_DIR,
+  GITHUB_ISSUES_REPO_URL,
+  ASCII_LOGO,
+  SESSION_ID,
+  CACHE_PATHS,
+  dateToFilename,
+  getMessagesPath,
+  parseLogFilename,
+  getNextAvailableLogForkNumber,
+  getNextAvailableLogSidechainNumber,
+  logError,
+  logMCPError,
+  overwriteLog,
+  formatDate,
+  loadLogList,
+  execFileNoThrow,
+  getKodeBaseDir,
+  getGlobalConfigFilePath,
+  getMemoryDir,
+  KODE_BASE_DIR,
+  GLOBAL_CONFIG_FILE,
+  MEMORY_DIR,
+  env,
+  getPlanFilePath,
+  isMainPlanFilePathForActiveConversation,
+  readPlanFile,
+  getPlanModeSystemPromptAdditions,
+  enterPlanMode,
+  enterPlanModeForConversationKey,
+  exitPlanModeForConversationKey
+};