@cydm/pie 1.0.4 → 1.0.6

package/dist/chunks/chunk-TG2EQLX2.js

@@ -0,0 +1,43 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/chunks/chunk-XZXLO7YB.js

@@ -0,0 +1,322 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// src/debug/file-logger.ts
+import * as fs from "fs";
+import * as path from "path";
+var FileLogger = class {
+  config = {
+    enabled: false,
+    filePath: this.getDefaultLogPath(),
+    maxBufferSize: 1e3
+  };
+  currentSessionId = null;
+  /**
+   * Get default log path - next to sessions directory for consistency
+   * ~/.pie/debug.log (Linux/macOS) or %USERPROFILE%\.pie\debug.log (Windows)
+   */
+  getDefaultLogPath() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
+    return path.join(homeDir, ".pie", "debug.log");
+  }
+  /**
+   * Get log path for a specific session
+   * ~/.pie/sessions/{sessionId}.log
+   */
+  getSessionLogPath(sessionId) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
+    return path.join(homeDir, ".pie", "sessions", `${sessionId}.log`);
+  }
+  buffer = [];
+  // Ring buffer for tail command
+  bufferIndex = 0;
+  totalLines = 0;
+  /**
+   * Check if logging is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Enable file logging
+   */
+  enable(filePath) {
+    this.config.enabled = true;
+    _LOG_ENABLED = true;
+    if (filePath) {
+      this.config.filePath = filePath;
+    }
+    const dir = path.dirname(this.config.filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.log("file-logger", `File logging enabled: ${this.config.filePath}`);
+  }
+  /**
+   * Disable file logging
+   */
+  disable() {
+    this.log("file-logger", "File logging disabled");
+    this.config.enabled = false;
+    _LOG_ENABLED = false;
+    this.currentSessionId = null;
+  }
+  /**
+   * Set session ID and update log path accordingly
+   * Log file will be: ~/.pie/sessions/{sessionId}.log
+   */
+  setSessionId(sessionId) {
+    const wasEnabled = this.config.enabled;
+    if (wasEnabled && this.currentSessionId && this.currentSessionId !== sessionId) {
+      this.log("file-logger", `Switching log from session ${this.currentSessionId} to ${sessionId}`);
+      this.config.enabled = false;
+    }
+    this.currentSessionId = sessionId;
+    if (sessionId) {
+      this.config.filePath = this.getSessionLogPath(sessionId);
+      if (wasEnabled) {
+        this.config.enabled = true;
+        const dir = path.dirname(this.config.filePath);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        this.log("file-logger", `File logging enabled for session ${sessionId}: ${this.config.filePath}`);
+      }
+    } else {
+      this.config.filePath = this.getDefaultLogPath();
+    }
+  }
+  /**
+   * Get current session ID
+   */
+  getSessionId() {
+    return this.currentSessionId;
+  }
+  /**
+   * Clear log file and buffer
+   */
+  clear() {
+    this.buffer = [];
+    this.bufferIndex = 0;
+    this.totalLines = 0;
+    if (fs.existsSync(this.config.filePath)) {
+      fs.writeFileSync(this.config.filePath, "");
+    }
+  }
+  /**
+   * Set module filter (undefined = all modules)
+   */
+  setModules(modules) {
+    this.config.modules = modules;
+  }
+  /**
+   * Main log method
+   */
+  log(module, message, data) {
+    if (!this.config.enabled) return;
+    if (this.config.modules && !this.config.modules.includes(module)) {
+      return;
+    }
+    const entry = this.formatEntry(module, message, data);
+    try {
+      fs.appendFileSync(this.config.filePath, entry + "\n");
+    } catch (err) {
+      return;
+    }
+    this.buffer[this.bufferIndex] = entry;
+    this.bufferIndex = (this.bufferIndex + 1) % this.config.maxBufferSize;
+    this.totalLines++;
+  }
+  /**
+   * Get recent log entries (for tail command)
+   */
+  tail(count = 20) {
+    const result = [];
+    const size = Math.min(count, this.buffer.length);
+    for (let i = 0; i < size; i++) {
+      const idx = (this.bufferIndex - size + i + this.config.maxBufferSize) % this.config.maxBufferSize;
+      if (this.buffer[idx]) {
+        result.push(this.buffer[idx]);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get log file stats
+   */
+  getStats() {
+    let size = 0;
+    if (fs.existsSync(this.config.filePath)) {
+      const stats = fs.statSync(this.config.filePath);
+      size = stats.size;
+    }
+    return {
+      path: this.config.filePath,
+      size,
+      lines: this.totalLines,
+      enabled: this.config.enabled
+    };
+  }
+  /**
+   * Read last N lines from file (fallback when buffer is not enough)
+   */
+  readLastLines(count) {
+    if (!fs.existsSync(this.config.filePath)) {
+      return [];
+    }
+    try {
+      const content = fs.readFileSync(this.config.filePath, "utf-8");
+      const lines = content.split("\n").filter(Boolean);
+      return lines.slice(-count);
+    } catch {
+      return [];
+    }
+  }
+  formatEntry(module, message, data) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    let entry = `[${timestamp}] [${module}] ${message}`;
+    if (data !== void 0) {
+      try {
+        entry += ` ${JSON.stringify(data)}`;
+      } catch {
+        entry += ` [Object]`;
+      }
+    }
+    return entry;
+  }
+};
+var fileLogger = new FileLogger();
+var _LOG_ENABLED = false;
+function isLogEnabled() {
+  return _LOG_ENABLED;
+}
+function debugLog(module, message, data) {
+  if (!_LOG_ENABLED) return;
+  fileLogger.log(module, message, data);
+}
+function withErrorLog(fn, context) {
+  if (!_LOG_ENABLED) return fn;
+  return ((...args) => {
+    try {
+      const result = fn(...args);
+      if (result && typeof result.then === "function" && typeof result.catch === "function") {
+        return result.catch((err) => {
+          if (_LOG_ENABLED) {
+            fileLogger.log("ERROR", `${context} FAILED`, {
+              error: err instanceof Error ? err.message : String(err),
+              stack: err instanceof Error ? err.stack : void 0
+            });
+          }
+          throw err;
+        });
+      }
+      return result;
+    } catch (err) {
+      if (_LOG_ENABLED) {
+        fileLogger.log("ERROR", `${context} FAILED`, {
+          error: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : void 0
+        });
+      }
+      throw err;
+    }
+  });
+}
+function setupGlobalErrorHandlers(fallbackWriter) {
+  process.on("uncaughtException", (err) => {
+    const entry = `[${(/* @__PURE__ */ new Date()).toISOString()}] [ERROR] UNCAUGHT EXCEPTION ${JSON.stringify({
+      name: err.name,
+      message: err.message,
+      type: "uncaughtException"
+    })}
+`;
+    try {
+      const logPath = fileLogger.getConfig().filePath;
+      const dir = path.dirname(logPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.appendFileSync(logPath, entry);
+    } catch {
+      console.error("UNCAUGHT EXCEPTION:", err);
+    }
+    try {
+      fallbackWriter?.("Uncaught Exception", err);
+    } catch {
+    }
+    setTimeout(() => process.exit(1), 100);
+  });
+  process.on("unhandledRejection", (reason, _promise) => {
+    try {
+      fallbackWriter?.("Unhandled Rejection", reason instanceof Error ? reason : new Error(String(reason)));
+    } catch {
+    }
+    if (_LOG_ENABLED) {
+      fileLogger.log("ERROR", "UNHANDLED REJECTION", {
+        reason: reason instanceof Error ? { name: reason.name, message: reason.message, stack: reason.stack } : String(reason),
+        type: "unhandledRejection"
+      });
+    }
+  });
+  process.on("warning", (warning) => {
+    if (_LOG_ENABLED) {
+      fileLogger.log("WARN", "NODE WARNING", {
+        name: warning.name,
+        message: warning.message,
+        stack: warning.stack,
+        type: "warning"
+      });
+    }
+  });
+}
+var _earlyLogs = [];
+var _earlyLogEnabled = false;
+function debugLogLazy(module, message, data) {
+  if (_LOG_ENABLED) {
+    fileLogger.log(module, message, data);
+    return;
+  }
+  if (_earlyLogEnabled) {
+    _earlyLogs.push({ module, message, data });
+    if (_earlyLogs.length > 100) {
+      _earlyLogs.shift();
+    }
+  }
+}
+function enableEarlyLogBuffer() {
+  _earlyLogEnabled = true;
+  if (process.env.PIE_DEBUG) {
+    fileLogger.enable();
+  }
+}
+function flushEarlyLogs() {
+  if (_earlyLogs.length === 0) return;
+  if (!_LOG_ENABLED) {
+    if (process.env.PIE_DEBUG) {
+      fileLogger.enable();
+    } else {
+      _earlyLogs = [];
+      return;
+    }
+  }
+  for (const log of _earlyLogs) {
+    fileLogger.log(log.module, log.message, log.data);
+  }
+  _earlyLogs = [];
+}
+
+export {
+  fileLogger,
+  isLogEnabled,
+  debugLog,
+  withErrorLog,
+  setupGlobalErrorHandlers,
+  debugLogLazy,
+  enableEarlyLogBuffer,
+  flushEarlyLogs
+};

package/dist/chunks/file-logger-AL5VVZHH.js

@@ -0,0 +1,22 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  debugLog,
+  debugLogLazy,
+  enableEarlyLogBuffer,
+  fileLogger,
+  flushEarlyLogs,
+  isLogEnabled,
+  setupGlobalErrorHandlers,
+  withErrorLog
+} from "./chunk-XZXLO7YB.js";
+import "./chunk-TG2EQLX2.js";
+export {
+  debugLog,
+  debugLogLazy,
+  enableEarlyLogBuffer,
+  fileLogger,
+  flushEarlyLogs,
+  isLogEnabled,
+  setupGlobalErrorHandlers,
+  withErrorLog
+};

package/dist/chunks/src-EGWRDMLB.js

@@ -0,0 +1,13 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  Agent,
+  agentLoop,
+  agentLoopContinue
+} from "./chunk-MWFBYJOI.js";
+import "./chunk-RID3574D.js";
+import "./chunk-TG2EQLX2.js";
+export {
+  Agent,
+  agentLoop,
+  agentLoopContinue
+};

package/dist/chunks/src-WRUACRN2.js

@@ -0,0 +1,132 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  AskUserMultiParamsSchema,
+  AskUserParamsSchema,
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  GREP_MAX_LINE_LENGTH,
+  ManageTodoListParamsSchema,
+  PLAN_MODE_TOOL_NAMES,
+  ReadSkillParamsSchema,
+  TodoItemSchema,
+  buildPathResolutionDescription,
+  buildRootParameterSchema,
+  buildTodoSuccessMessage,
+  cloneTodos,
+  collectLastAssistantText,
+  collectSharedCapabilityPromptAdditions,
+  createAskUserCapability,
+  createEditTool,
+  createFileSystemTools,
+  createFindTool,
+  createGrepTool,
+  createLsTool,
+  createManageTodoCapability,
+  createPlanCapability,
+  createReadOnlyTools,
+  createReadSkillCapability,
+  createReadTool,
+  createSharedFileSystemTools,
+  createSharedReadOnlyTools,
+  createSubagentCapability,
+  createTodoStore,
+  createWriteTool,
+  defineSharedCapability,
+  detectLineEnding,
+  executeManageTodoList,
+  extractDoneSteps,
+  extractPlanTodoItems,
+  formatSize,
+  formatSkillsForPrompt,
+  fuzzyFindText,
+  generateDiffString,
+  getAvailableRoots,
+  getDefaultRootName,
+  getSharedCapabilityPromptAdditionsForToolNames,
+  getTodoStats,
+  getTodoValidation,
+  isPlanModeSafeCommand,
+  markCompletedPlanSteps,
+  normalizeForFuzzyMatch,
+  normalizeStatus,
+  normalizeToLF,
+  normalizeTodos,
+  resolveInSandbox,
+  resolveReadPath,
+  resolveToCwd,
+  restoreLineEndings,
+  restoreTodoState,
+  restoreTodosFromMessages,
+  stripBom,
+  truncateHead,
+  truncateLine,
+  truncateTail,
+  validateTodos
+} from "./chunk-TBJ25UWB.js";
+import "./chunk-MWFBYJOI.js";
+import "./chunk-RID3574D.js";
+import "./chunk-TG2EQLX2.js";
+export {
+  AskUserMultiParamsSchema,
+  AskUserParamsSchema,
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  GREP_MAX_LINE_LENGTH,
+  ManageTodoListParamsSchema,
+  PLAN_MODE_TOOL_NAMES,
+  ReadSkillParamsSchema,
+  TodoItemSchema,
+  buildPathResolutionDescription,
+  buildRootParameterSchema,
+  buildTodoSuccessMessage,
+  cloneTodos,
+  collectLastAssistantText,
+  collectSharedCapabilityPromptAdditions,
+  createAskUserCapability,
+  createEditTool,
+  createFileSystemTools,
+  createFindTool,
+  createGrepTool,
+  createLsTool,
+  createManageTodoCapability,
+  createPlanCapability,
+  createReadOnlyTools,
+  createReadSkillCapability,
+  createReadTool,
+  createSharedFileSystemTools,
+  createSharedReadOnlyTools,
+  createSubagentCapability,
+  createTodoStore,
+  createWriteTool,
+  defineSharedCapability,
+  detectLineEnding,
+  executeManageTodoList,
+  extractDoneSteps,
+  extractPlanTodoItems,
+  formatSize,
+  formatSkillsForPrompt,
+  fuzzyFindText,
+  generateDiffString,
+  getAvailableRoots,
+  getDefaultRootName,
+  getSharedCapabilityPromptAdditionsForToolNames,
+  getTodoStats,
+  getTodoValidation,
+  isPlanModeSafeCommand,
+  markCompletedPlanSteps,
+  normalizeForFuzzyMatch,
+  normalizeStatus,
+  normalizeToLF,
+  normalizeTodos,
+  resolveInSandbox,
+  resolveReadPath,
+  resolveToCwd,
+  restoreLineEndings,
+  restoreTodoState,
+  restoreTodosFromMessages,
+  stripBom,
+  truncateHead,
+  truncateLine,
+  truncateTail,
+  validateTodos
+};