@cydm/pie 1.0.47 → 1.0.49

package/README.md

@@ -218,7 +218,10 @@ Pie uses a hierarchical slash-command menu. The current built-in commands includ
 | `pie doctor [--json]` | Diagnose local config, model setup, writable paths, browser automation, and Unity bridge hints |
 | `pie models init` | Create a starter `~/.pie/models.json` |
 | `pie models validate` | Validate `~/.pie/models.json` |
-| `pie permissions` | Explain tool and shell safety defaults |
+| `pie permissions` | Explain tool and shell safety defaults (`--json` returns the structured safety model) |
+| `pie capabilities [--json]` | Report the command surface, flags, exit codes, and output schema for agents |
+| `pie sessions list/read/rename/rewind/fork` | Inspect and manage stored sessions non-interactively (each supports `--json` and `--help`) |
+| `pie extensions list/enable/disable` | Inspect and toggle extensions non-interactively |
 | `/sessions/compact` | Summarize history and create a compact checkpoint |
 | `/sessions/new` | Start a new session |
 | `/sessions/resume` | Resume a different session |
@@ -355,6 +358,23 @@ pie "summarize this file" --json-output
 pie "continue previous task" --session-id my-session
 ```
 
+### Machine-Readable Output (Agents And Hosts)
+
+Every management command (`sessions`, `doctor`, `models`, `extensions`, `permissions`, `capabilities`) emits one compact JSON envelope when given `--json`:
+
+```json
+{"v":1,"ok":true,"kind":"sessions.list","data":[...],"meta":{"count":10,"total":42,"nextCursor":"..."},"help":["..."]}
+```
+
+- `v` is a constant output-schema generation marker; `kind` identifies the command.
+- `meta` carries pagination (`nextCursor`) and aggregates; `help[]` lists concrete next steps when they exist and never duplicates large payloads.
+- Errors are structured on stdout: `{"v":1,"ok":false,"kind":"...","error":{"code":"session_not_found","message":"...","hint":"..."}}`.
+- Exit codes: `0` success, `1` business failure, `2` usage error. Unknown flags fail loudly; every subcommand supports `--help`.
+- `sessions list --json` defaults to the current project (`--all` lists every project). Rows are minimal (`id`, `name`, `updatedAt`, `count`) with `--fields` and `--full` opt-ins; `sessions read` truncates content by default with the same opt-ins.
+- JSONL protocol mode (`--json-events`) identifies entries by `entryId` only (the legacy `checkpointId` alias is gone) and caps large tool results and turn summaries by default; pass `--event-detail full` for untruncated payloads. Truncation always carries `truncated`/`fullLength` markers.
+
+Run `pie capabilities --json` to discover the full command surface, flags, and exit-code contract programmatically.
+
 ## Terminal Notes
 
 For the best multiline editing experience, use a terminal with good modified-key support, such as:

package/dist/builtin/extensions/ask-user/index.js

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createAskUserCapability
-} from "../../../chunks/chunk-IJMP3JTX.js";
+} from "../../../chunks/chunk-7RYOIXA2.js";
 import "../../../chunks/chunk-FKAO25XH.js";
 import "../../../chunks/chunk-K6ZOCJ4V.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";

package/dist/builtin/extensions/plan-mode/index.js

@@ -7,7 +7,7 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-IJMP3JTX.js";
+} from "../../../chunks/chunk-7RYOIXA2.js";
 import "../../../chunks/chunk-FKAO25XH.js";
 import {
   Type

package/dist/builtin/extensions/subagent/index.js

@@ -1,11 +1,11 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createCliHostCapabilities
-} from "../../../chunks/chunk-U4B6RJ6Z.js";
+} from "../../../chunks/chunk-J6PEH6ST.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-IJMP3JTX.js";
+} from "../../../chunks/chunk-7RYOIXA2.js";
 import "../../../chunks/chunk-FKAO25XH.js";
 import "../../../chunks/chunk-K6ZOCJ4V.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";

package/dist/builtin/extensions/todo/index.js

@@ -7,7 +7,7 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-IJMP3JTX.js";
+} from "../../../chunks/chunk-7RYOIXA2.js";
 import "../../../chunks/chunk-FKAO25XH.js";
 import "../../../chunks/chunk-K6ZOCJ4V.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";

package/dist/chunks/{chunk-IJMP3JTX.js → chunk-7RYOIXA2.js}

@@ -7869,6 +7869,193 @@ function fuzzyFindText(content, oldText) {
 function stripBom(content) {
   return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
 }
+function findEditMatch(content, oldText, newText) {
+  const direct = fuzzyFindText(content, oldText);
+  if (direct.found) {
+    return { found: true, occurrences: direct.occurrences, matches: direct.matches, matchKind: direct.matchKind };
+  }
+  return findWhitespaceRelaxedMatch(content, oldText, newText);
+}
+function leadingWhitespace(line) {
+  const match2 = line.match(/^[ \t]*/);
+  return match2 ? match2[0] : "";
+}
+function findRelaxedWindows(fileLines, qLines) {
+  const firstNonBlank = qLines.findIndex((line) => line.trim() !== "");
+  if (firstNonBlank === -1) return [];
+  const anchor = qLines[firstNonBlank].trim();
+  if (!anchor) return [];
+  const windows = [];
+  for (let anchorFileLine = 0; anchorFileLine < fileLines.length; anchorFileLine++) {
+    if (fileLines[anchorFileLine].trim() !== anchor) continue;
+    const startLine = anchorFileLine - firstNonBlank;
+    if (startLine < 0) continue;
+    let fileLine = startLine;
+    let ok = true;
+    let lastPaired = -1;
+    const qLineToFileLine = /* @__PURE__ */ new Map();
+    for (let qLine = 0; qLine < qLines.length; qLine++) {
+      if (fileLine >= fileLines.length) {
+        ok = false;
+        break;
+      }
+      const q = qLines[qLine];
+      const f = fileLines[fileLine];
+      if (q.trim() === "") {
+        if (f.trim() !== "") {
+          ok = false;
+          break;
+        }
+      } else {
+        if (f.trim() !== q.trim()) {
+          ok = false;
+          break;
+        }
+        qLineToFileLine.set(qLine, fileLine);
+        lastPaired = fileLine;
+      }
+      fileLine++;
+    }
+    if (ok && lastPaired !== -1) windows.push({ startLine, endLine: lastPaired, qLineToFileLine });
+  }
+  return windows;
+}
+function lineSpanToCharSpan(fileLines, startLine, endLine) {
+  let index = 0;
+  for (let i = 0; i < startLine; i++) index += fileLines[i].length + 1;
+  let matchLength = 0;
+  for (let i = startLine; i <= endLine; i++) matchLength += fileLines[i].length + (i < endLine ? 1 : 0);
+  return { index, matchLength };
+}
+function reindentNewText(newText, qLines, fileLines, window) {
+  const newLines = newText.split("\n");
+  const qIndent = (qLine) => {
+    const fileLine = window.qLineToFileLine.get(qLine);
+    return fileLine === void 0 ? "" : leadingWhitespace(fileLines[fileLine]);
+  };
+  const qIdx = [];
+  for (let i = 0; i < qLines.length; i++) if (qLines[i].trim() !== "") qIdx.push(i);
+  const nIdx = [];
+  const nPosOfLine = /* @__PURE__ */ new Map();
+  for (let i = 0; i < newLines.length; i++) {
+    if (newLines[i].trim() === "") continue;
+    nPosOfLine.set(i, nIdx.length);
+    nIdx.push(i);
+  }
+  if (nIdx.length === 0) return newText;
+  const counterpart = /* @__PURE__ */ new Map();
+  let p = 0;
+  while (p < qIdx.length && p < nIdx.length && qLines[qIdx[p]].trim() === newLines[nIdx[p]].trim()) {
+    counterpart.set(p, p);
+    p++;
+  }
+  let s = 0;
+  while (s < qIdx.length - p && s < nIdx.length - p && qLines[qIdx[qIdx.length - 1 - s]].trim() === newLines[nIdx[nIdx.length - 1 - s]].trim()) {
+    counterpart.set(nIdx.length - 1 - s, qIdx.length - 1 - s);
+    s++;
+  }
+  const midQ = [];
+  for (let pos = p; pos < qIdx.length - s; pos++) midQ.push(pos);
+  const midN = [];
+  for (let pos = p; pos < nIdx.length - s; pos++) midN.push(pos);
+  const pairRegion = (qLo, qHi, nLo, nHi) => {
+    const qCount = qHi - qLo;
+    const nCount = nHi - nLo;
+    const paired = Math.min(qCount, nCount);
+    for (let k = 0; k < paired; k++) counterpart.set(nLo + k, qLo + k);
+    const fallbackQ = qCount > 0 ? qHi - 1 : Math.max(qLo - 1, 0);
+    for (let k = paired; k < nCount; k++) counterpart.set(nLo + k, fallbackQ);
+  };
+  const qTextCounts = /* @__PURE__ */ new Map();
+  for (const qPos of midQ) {
+    const t = qLines[qIdx[qPos]].trim();
+    qTextCounts.set(t, (qTextCounts.get(t) ?? 0) + 1);
+  }
+  const qPosByText = /* @__PURE__ */ new Map();
+  for (const qPos of midQ) {
+    const t = qLines[qIdx[qPos]].trim();
+    if (qTextCounts.get(t) === 1) qPosByText.set(t, qPos);
+  }
+  const nTextCounts = /* @__PURE__ */ new Map();
+  for (const nPos of midN) {
+    const t = newLines[nIdx[nPos]].trim();
+    nTextCounts.set(t, (nTextCounts.get(t) ?? 0) + 1);
+  }
+  let cursorQ = p;
+  let cursorN = p;
+  for (const nPos of midN) {
+    const t = newLines[nIdx[nPos]].trim();
+    const qPos = qPosByText.get(t);
+    if (nTextCounts.get(t) !== 1 || qPos === void 0 || qPos < cursorQ) continue;
+    pairRegion(cursorQ, qPos, cursorN, nPos);
+    counterpart.set(nPos, qPos);
+    cursorQ = qPos + 1;
+    cursorN = nPos + 1;
+  }
+  pairRegion(cursorQ, qIdx.length - s, cursorN, nIdx.length - s);
+  const result = [];
+  for (let i = 0; i < newLines.length; i++) {
+    if (newLines[i].trim() === "") {
+      result.push("");
+      continue;
+    }
+    const nPos = nPosOfLine.get(i) ?? 0;
+    const qPos = counterpart.get(nPos) ?? 0;
+    result.push(qIndent(qIdx[qPos] ?? qIdx[0]) + newLines[i].trim());
+  }
+  return result.join("\n");
+}
+function findWhitespaceRelaxedMatch(content, oldText, newText) {
+  const fileLines = content.split("\n");
+  const qLines = oldText.split("\n");
+  const windows = findRelaxedWindows(fileLines, qLines);
+  if (windows.length === 0) {
+    return { found: false, occurrences: 0, matches: [], matchKind: "none" };
+  }
+  const matches = windows.map((window) => {
+    const span = lineSpanToCharSpan(fileLines, window.startLine, window.endLine);
+    return { ...span, replacementText: reindentNewText(newText, qLines, fileLines, window) };
+  });
+  return { found: true, occurrences: matches.length, matches, matchKind: "whitespace-relaxed" };
+}
+function describeClosestRegion(content, oldText) {
+  const qLines = oldText.split("\n");
+  const firstNonBlank = qLines.findIndex((line) => line.trim() !== "");
+  if (firstNonBlank === -1) return void 0;
+  const anchor = qLines[firstNonBlank].trim();
+  const fileLines = content.split("\n");
+  const clip = (text) => text.length > 90 ? `${text.slice(0, 90)}\u2026` : text;
+  let best;
+  for (let i = 0; i < fileLines.length; i++) {
+    if (fileLines[i].trim() !== anchor) continue;
+    let matched = 0;
+    let fi = i;
+    let firstDiff;
+    for (let qi = firstNonBlank; qi < qLines.length; qi++) {
+      const q = qLines[qi].trim();
+      if (!q) continue;
+      while (fi < fileLines.length && !fileLines[fi].trim()) fi++;
+      if (fi >= fileLines.length || fileLines[fi].trim() !== q) {
+        firstDiff = { fileNo: fi + 1, fileLine: fileLines[fi] ?? "<end of file>", qLine: qLines[qi] };
+        break;
+      }
+      matched++;
+      fi++;
+    }
+    if (!best || matched > best.matched) best = { start: i, matched, firstDiff };
+  }
+  const total = qLines.filter((line) => line.trim() !== "").length;
+  if (!best) {
+    return `No line matching ${JSON.stringify(clip(anchor))} exists in this file \u2014 the text may live in a different file, or the file changed since it was read.`;
+  }
+  const parts = [`Closest match: file lines ${best.start + 1}\u2013${best.start + total} (${best.matched}/${total} lines matched by trimmed content).`];
+  if (best.firstDiff) {
+    parts.push(`First difference at line ${best.firstDiff.fileNo}: file has ${JSON.stringify(clip(best.firstDiff.fileLine.trim()))}, edit expected ${JSON.stringify(clip(best.firstDiff.qLine.trim()))}.`);
+  } else {
+    parts.push("All non-empty lines match by trimmed content \u2014 the mismatch is leading whitespace or blank-line placement.");
+  }
+  return parts.join(" ");
+}
 function generateDiffString(oldContent, newContent, contextLines = 4) {
   const oldLines = normalizeToLF(stripBom(oldContent).text).split("\n");
   const newLines = normalizeToLF(stripBom(newContent).text).split("\n");
@@ -7982,7 +8169,8 @@ function createEditErrorResult(params) {
   const detailLines = [
     params.message,
     params.recoveryHint,
-    params.alreadyAppliedCandidate ? "Diagnostic: newText already appears in the current file, but edit_file did not treat that as success because it may be an unrelated occurrence." : ""
+    params.alreadyAppliedCandidate ? "Diagnostic: newText already appears in the current file, but edit_file did not treat that as success because it may be an unrelated occurrence." : "",
+    params.closestMatch ? `Diagnostic: ${params.closestMatch}` : ""
   ].filter(Boolean);
   return {
     content: [{ type: "text", text: detailLines.join("\n") }],
@@ -8034,7 +8222,7 @@ function createEditTool(cwd, options) {
       newText: Type.String({ description: "Replacement text", maxLength: MAX_EDIT_INPUT_CHARS }),
       replaceAll: Type.Optional(Type.Boolean({ description: "Replace every occurrence" }))
     }), {
-      description: "One or more independent replacements matched against the original file",
+      description: "Replacements applied in order: each edit matches the file as left by the previous edit, so later edits can build on earlier ones. Whole-line indentation drift is tolerated \u2014 matches locate by trimmed content and the replacement adopts the file's indentation.",
       minItems: 1,
       maxItems: MAX_EDIT_BLOCKS
     })
@@ -8043,7 +8231,7 @@ function createEditTool(cwd, options) {
   return {
     name: "edit",
     label: "edit",
-    description: `Make precise exact-text replacements in one file. For multiple changes in the same file, put all independent replacements in one edits[] call. ${pathResolutionDescription}`,
+    description: `Make precise exact-text replacements in one file. For multiple changes in the same file, put all replacements in one edits[] call \u2014 they apply in order, so later edits can target what earlier ones just changed. ${pathResolutionDescription}`,
     parameters: editSchema,
     execute: async (_toolCallId, params, signal) => {
       const { path: path4, root } = params;
@@ -8087,7 +8275,9 @@ function createEditTool(cwd, options) {
             const { bom, text: content } = stripBom(rawContent);
             const originalEnding = detectLineEnding(content);
             const normalizedContent = normalizeToLF(content);
-            const planned = [];
+            let workingContent = normalizedContent;
+            const plannedKinds = /* @__PURE__ */ new Set();
+            let replacedOccurrences = 0;
             let totalOldOccurrences = 0;
             let totalNewOccurrences = 0;
             let anyReplaceAll = false;
@@ -8095,8 +8285,8 @@ function createEditTool(cwd, options) {
               throwIfAborted();
               const normalizedOldText = normalizeToLF(replacement.oldText);
               const normalizedNewText = normalizeToLF(replacement.newText);
-              const newTextOccurrences = countOccurrences(normalizedContent, normalizedNewText);
-              const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+              const newTextOccurrences = countOccurrences(workingContent, normalizedNewText);
+              const matchResult = findEditMatch(workingContent, normalizedOldText, normalizedNewText);
               totalOldOccurrences += matchResult.occurrences;
               totalNewOccurrences += newTextOccurrences;
               anyReplaceAll ||= replacement.replaceAll;
@@ -8111,7 +8301,8 @@ function createEditTool(cwd, options) {
                   replaceAll: replacement.replaceAll,
                   staleBaseLikely: newTextOccurrences > 0,
                   alreadyAppliedCandidate: newTextOccurrences > 0,
-                  recoveryHint: newTextOccurrences > 0 ? "The replacement may already be present. Read the current file before retrying." : "Read the latest file and retry with exact text."
+                  recoveryHint: newTextOccurrences > 0 ? "The replacement may already be present. Read the current file before retrying." : "Read the latest file and retry with exact text.",
+                  closestMatch: describeClosestRegion(workingContent, normalizedOldText)
                 }));
                 return;
               }
@@ -8128,9 +8319,9 @@ function createEditTool(cwd, options) {
                 }));
                 return;
               }
-              const matches = replacement.replaceAll ? matchResult.matches : matchResult.matches.slice(0, 1);
-              const changingMatches = matches.filter(
-                (match2) => normalizedContent.slice(match2.index, match2.index + match2.matchLength) !== normalizedNewText
+              const selected = replacement.replaceAll ? matchResult.matches : matchResult.matches.slice(0, 1);
+              const changingMatches = selected.filter(
+                (match2) => workingContent.slice(match2.index, match2.index + match2.matchLength) !== (match2.replacementText ?? normalizedNewText)
               );
               if (changingMatches.length === 0) {
                 if (signal) signal.removeEventListener("abort", onAbort);
@@ -8146,42 +8337,20 @@ function createEditTool(cwd, options) {
                 }));
                 return;
               }
-              for (const match2 of changingMatches) {
-                planned.push({ ...match2, newText: normalizedNewText, matchKind: matchResult.matchKind });
-              }
-            }
-            const ordered = [...planned].sort((left, right) => left.index - right.index);
-            for (let index = 1; index < ordered.length; index++) {
-              throwIfAborted();
-              const previous = ordered[index - 1];
-              const current = ordered[index];
-              if (current.index < previous.index + previous.matchLength) {
-                if (signal) signal.removeEventListener("abort", onAbort);
-                resolve3(createEditErrorResult({
-                  message: `Edits overlap in ${path4}; no changes were made.`,
-                  matchKind: "mixed",
-                  errorReason: "overlapping_edits",
-                  oldTextOccurrences: totalOldOccurrences,
-                  newTextOccurrences: totalNewOccurrences,
-                  replaceAll: anyReplaceAll,
-                  recoveryHint: "Merge overlapping replacements into one exact edit."
-                }));
-                return;
+              for (const match2 of [...changingMatches].sort((left, right) => right.index - left.index)) {
+                throwIfAborted();
+                workingContent = workingContent.substring(0, match2.index) + (match2.replacementText ?? normalizedNewText) + workingContent.substring(match2.index + match2.matchLength);
+                replacedOccurrences++;
+                if (matchResult.matchKind !== "none") plannedKinds.add(matchResult.matchKind);
               }
             }
             throwIfAborted();
-            const baseContent = normalizedContent;
-            let newContent = baseContent;
-            for (const match2 of [...planned].sort((left, right) => right.index - left.index)) {
-              throwIfAborted();
-              newContent = newContent.substring(0, match2.index) + match2.newText + newContent.substring(match2.index + match2.matchLength);
-            }
-            if (baseContent === newContent) {
+            if (workingContent === normalizedContent) {
               if (signal) signal.removeEventListener("abort", onAbort);
               resolve3(
                 createEditErrorResult({
                   message: `No changes made to ${path4}. The replacement produced identical content.`,
-                  matchKind: planned.every((match2) => match2.matchKind === planned[0]?.matchKind) ? planned[0]?.matchKind ?? "none" : "mixed",
+                  matchKind: plannedKinds.size === 1 ? [...plannedKinds][0] : "mixed",
                   errorReason: "replacement_no_change",
                   oldTextOccurrences: totalOldOccurrences,
                   newTextOccurrences: totalNewOccurrences,
@@ -8192,6 +8361,7 @@ function createEditTool(cwd, options) {
               );
               return;
             }
+            const newContent = workingContent;
             const finalContent = bom + restoreLineEndings(newContent, originalEnding);
             throwIfAborted();
             await fs2.writeFile(absolutePath, finalContent, "utf-8");
@@ -8201,13 +8371,12 @@ function createEditTool(cwd, options) {
               signal.removeEventListener("abort", onAbort);
             }
             const diffResult = generateDiffString(content, restoreLineEndings(newContent, originalEnding));
-            const matchKinds = new Set(planned.map((match2) => match2.matchKind));
-            const matchKind = matchKinds.size === 1 ? planned[0]?.matchKind ?? "none" : "mixed";
+            const matchKind = plannedKinds.size === 1 ? [...plannedKinds][0] : "mixed";
             resolve3({
               content: [
                 {
                   type: "text",
-                  text: `Changed ${path4}: ${replacements.length} edit block${replacements.length === 1 ? "" : "s"}, ${planned.length} replacement${planned.length === 1 ? "" : "s"}. First changed line: ${diffResult.firstChangedLine}.`
+                  text: `Changed ${path4}: ${replacements.length} edit block${replacements.length === 1 ? "" : "s"}, ${replacedOccurrences} replacement${replacedOccurrences === 1 ? "" : "s"}. First changed line: ${diffResult.firstChangedLine}.`
                 },
                 { type: "text", text: boundedDiff(diffResult.diff) }
               ],
@@ -8221,7 +8390,7 @@ function createEditTool(cwd, options) {
                 oldTextOccurrences: totalOldOccurrences,
                 newTextOccurrences: totalNewOccurrences,
                 replaceAll: anyReplaceAll,
-                replacedOccurrences: planned.length,
+                replacedOccurrences,
                 replacedBlocks: replacements.length
               }
             });

package/dist/chunks/{chunk-U4B6RJ6Z.js → chunk-J6PEH6ST.js}

@@ -8,7 +8,7 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-IJMP3JTX.js";
+} from "./chunk-7RYOIXA2.js";
 import {
   Type
 } from "./chunk-K6ZOCJ4V.js";