pi-supernova 0.10.1 → 0.11.0

package/src/contract/edit.js

@@ -20,7 +20,7 @@ export function viewSpan(value) {
 }
 
 export function isEditView(value) {
-  return isObject(value) && !Array.isArray(value) && isString(value.path) && value.path.trim() && isString(value.text) && (value.status === undefined || value.status === "found") && viewSpan(value);
+  return isObject(value) && !Array.isArray(value) && isString(value.path) && value.path.length > 0 && isString(value.text) && (value.status === undefined || value.status === "found") && viewSpan(value);
 }
 
 function classifyViewEdit(p, oldText, newText) {
@@ -60,7 +60,7 @@ function normalizeEditArgs(p, oldText, newText) {
 function namedEditArgs(p, oldText, newText) {
   const args = normalizeEditArgs(p, oldText, newText);
 
-  if (!isString(args.path) || !args.path.trim()) throw new Error(EDIT_USAGE);
+  if (!isString(args.path) || args.path.length === 0) throw new Error(EDIT_USAGE);
 
   return args;
 }
@@ -82,18 +82,32 @@ function classifyReplacements(args) {
 
   if (!Array.isArray(edits) || !edits.length) throw new Error(EDIT_USAGE);
 
-  for (const e of edits) if (!isString(e?.oldText) || !e.oldText.length || !isString(e?.newText)) throw new Error(EDIT_USAGE + "; replacements require non-empty oldText and string newText");
+  for (const [i, edit] of edits.entries()) {
+    if (!validReplacement(edit)) throw new Error(replacementError(edit));
+
+    if (args.edits !== undefined) assertEditOptions(edit, REPLACEMENT_OPTION_KEYS, "edit " + (i + 1) + " of " + edits.length);
+  }
 
   return { kind: "edits", command: "edit", args };
 }
 
+function validReplacement(edit) {
+  return isString(edit?.oldText) && !!edit.oldText.length && isString(edit?.newText);
+}
+
+function replacementError(edit) {
+  return EDIT_USAGE + "; replacements require non-empty oldText and string newText" + (isString(edit?.oldText) && !edit.oldText.length ? "; to insert, include adjacent existing text in oldText and repeat it in newText" : "");
+}
+
 const EDIT_OPTION_KEYS = ["path", "oldText", "newText", "edits", "patch"];
 
+const REPLACEMENT_OPTION_KEYS = ["oldText", "newText"];
+
 /** A view object carries host fields; only named replacements are validated. */
-function assertEditOptions(args) {
-  const unknown = Object.keys(args).filter(key => !EDIT_OPTION_KEYS.includes(key));
+function assertEditOptions(args, allowed = EDIT_OPTION_KEYS, label = "edit") {
+  const unknown = Object.keys(args).filter(key => !allowed.includes(key));
 
-  if (unknown.length) throw new Error("edit does not accept option " + unknown.map(key => JSON.stringify(key)).join(", ") + "; supported options are path, oldText, newText, edits, patch");
+  if (unknown.length) throw new Error(label + " does not accept option " + unknown.map(key => JSON.stringify(key)).join(", ") + "; supported options are " + allowed.join(", "));
 }
 
 function classifyNamedEdit(p, oldText, newText) {
@@ -106,7 +120,12 @@ function classifyNamedEdit(p, oldText, newText) {
 
 /** Guest signature → { command, args } for one host call. */
 export function classifyEdit(p, oldText, newText) {
-  if (isFunction(p)) return { kind: "checkpoint", fn: p };
+  if (isFunction(p)) {
+    if (oldText !== undefined || newText !== undefined) throw new Error(EDIT_USAGE);
+
+    return { kind: "checkpoint", fn: p };
+  }
+
   if (isEditView(p) && isString(oldText) && (newText === undefined || isString(newText))) return classifyViewEdit(p, oldText, newText);
 
   return classifyNamedEdit(p, oldText, newText);

package/src/contract/program.js

@@ -9,7 +9,8 @@ try {
   Type = require("typebox").Type;
 } catch {
   Type = {
-    Object: (props, opts) => ({ type: "object", properties: props || {}, additionalProperties: false, ...opts }),
+    // Match Type.Object defaults; explicit nested-entry guards live in opts.
+    Object: (props, opts) => ({ type: "object", properties: props || {}, ...opts }),
     String: (opts) => ({ type: "string", ...opts }),
     Unknown: (opts) => ({ ...opts }),
     Array: (items, opts) => ({ type: "array", items, ...opts }),

package/src/contract/read.js

@@ -1,11 +1,11 @@
-import { errorMessage, isString, isObject, isNumber, looksLikePath } from "../shared/decode.js";
+import { errorMessage, isString, isObject, looksLikePath } from "../shared/decode.js";
 import { foldJsonSelectorAlias, sessionJsonArgs, validateJsonRead } from "../fs/json-read.js";
 
 export const SESSION_URI = /^(?:agent|artifact):\/\//i;
 
-const BOOL_KEYS = ["resolve", "complete", "outline", "evidence"];
+const BOOL_KEYS = ["resolve", "complete", "outline", "evidence", "indexed"];
 
-const READ_OPTION_KEYS = ["path", "target", "about", "query", "offset", "limit", "json", "resolve", "complete", "outline", "evidence", "maxChars", "_independent"];
+const READ_OPTION_KEYS = ["path", "target", "about", "query", "offset", "limit", "json", "resolve", "complete", "outline", "evidence", "maxChars", "indexed", "_independent"];
 
 /** Unknown options used to be dropped silently: {start,end} read the whole file. */
 function assertReadOptions(args) {
@@ -26,25 +26,28 @@ export function isSessionUri(value) {
 
 /** Guest call shape → one options object. */
 export function gatherReadArgs(p, a, b) {
-  if (isObject(p) && !Array.isArray(p)) {
-    const args = { ...p, path: p.path ?? p.target ?? p.query };
-
-    if (p.path === undefined && p.target !== undefined) delete args.target;
-
-    return args;
-  }
+  if (isObject(p) && !Array.isArray(p)) return gatherObjectReadArgs(p);
 
   // Only the string shorthand guesses between a path and a symbol. Explicit
   // path/target objects and path arrays must not turn missing files into search.
   return autoResolve(isObject(a) && !Array.isArray(a) ? { path: p, ...a } : { path: p, offset: a, limit: b });
 }
 
+function gatherObjectReadArgs(p) {
+  // Query text is not a scope, even when it looks like a filename.
+  const args = { ...p, path: p.path ?? p.target ?? (p.query !== undefined ? "." : undefined) };
+
+  if (p.path === undefined && p.target !== undefined) delete args.target;
+
+  return args;
+}
+
 export function assertReadPaths(targetParam) {
   if (!Array.isArray(targetParam)) return;
 
   if (targetParam.length > 64) throw new Error("read accepts at most 64 paths per batch");
 
-  for (const item of targetParam) if (!isString(item) || !item.trim()) throw new Error("read paths must be non-empty strings");
+  for (const item of targetParam) if (!isString(item) || item.length === 0) throw new Error("read paths must be non-empty strings");
 }
 
 function assertReadFlags(args) {
@@ -57,11 +60,19 @@ function assertReadFlags(args) {
   if (args.query !== undefined && !isString(args.query)) throw new Error("read query must be a string");
 }
 
-function assertExclusiveRead(args) {
+function assertFocusModes(args) {
   const focusModes = [args.about !== undefined, args.query !== undefined, args.outline === true].filter(Boolean).length;
 
   if (focusModes > 1 || (args.outline === true && args.evidence === true)) throw new Error("read accepts only one of about, query, outline, or evidence");
 
+  return focusModes;
+}
+
+function assertExclusiveRead(args) {
+  if (args.indexed === true && indexedConflict(args)) throw new Error("indexed:true requires a source query, not another read mode or explicit window");
+
+  const focusModes = assertFocusModes(args);
+
   if (args.resolve === true && args.complete === true) throw new Error("read accepts either resolve or complete, not both");
 
   if ((focusModes === 1 || args.evidence === true) && args.complete === true) throw new Error("complete:true requires a raw file read, not a source view");
@@ -70,7 +81,7 @@ function assertExclusiveRead(args) {
 function autoResolve(args) {
   if (!isString(args.path) || args.resolve !== undefined || args.complete === true || args.json !== undefined) return args;
 
-  if (args.about !== undefined || args.query !== undefined || args.offset !== undefined || args.limit !== undefined || looksLikePath(args.path) || isSessionUri(args.path)) return args;
+  if (hasDefinedOption(args, ["about", "query", "offset", "limit"]) || looksLikePath(args.path) || isSessionUri(args.path)) return args;
 
   return { ...args, resolve: true };
 }
@@ -103,20 +114,30 @@ export function needsProbe(params) {
  * Kind of read after exclusive modes are already validated.
  * `existing` is the probe result, or null/undefined when needsProbe is false or the path is missing.
  */
-function classifyExisting(params, existing) {
-  if (existing.directory) {
-    if (params.json !== undefined) throw new Error("JSON read requires a file, not a directory");
+function hasDefinedOption(args, keys) {
+  return keys.some(key => args[key] !== undefined);
+}
 
-    return isString(params.about)
-      ? { kind: "snap", query: params.about, scoped: true, existing }
-      : { kind: "dir", existing };
-  }
+function indexedConflict(args) {
+  return hasDefinedOption(args, ["about", "json", "offset", "limit"]) || ["outline", "evidence", "complete"].some(key => args[key] === true);
+}
+
+function classifyDirectory(params, existing) {
+  if (params.json !== undefined) throw new Error("JSON read requires a file, not a directory");
+
+  return isString(params.about)
+    ? { kind: "snap", query: params.about, scoped: true, existing }
+    : { kind: "dir", existing };
+}
+
+function classifyExisting(params, existing) {
+  if (existing.directory) return classifyDirectory(params, existing);
 
   if (params.resolve === true && isString(params.about)) {
     throw new Error("resolve:true cannot combine with about on a file; use about for a focused outline or resolve for source text");
   }
 
-  if (isString(params.about) && existing.size > 512 * 1024) return { kind: "focus", existing, about: params.about };
+  if (isString(params.about) && (existing.size > 512 * 1024 || /\.(?:md|markdown)$/i.test(existing.path))) return { kind: "focus", existing, about: params.about };
 
   return { kind: params.resolve ? "open" : "file", existing };
 }
@@ -166,37 +187,16 @@ function jsonSelectorNote(args) {
   return args.json === undefined ? "" : " (" + (Array.isArray(args.json) ? args.json.join(", ") : String(args.json)) + ")";
 }
 
-export const ROUTING_STATUS = "too_large";
-
-const ROUTING_PREFIX = '{"status":"too_large",';
-
-export function isRoutingPayload(value) {
-  return isString(value) && value.startsWith(ROUTING_PREFIX);
-}
-
-function isRoutingObject(parsed) {
-  return isObject(parsed) && parsed.status === ROUTING_STATUS && isString(parsed.path)
-    && isNumber(parsed.chars) && (Array.isArray(parsed.keys) || isNumber(parsed.length));
-}
-
 function decodeByArgs(args, value) {
   return (args.resolve || args.json !== undefined || args.outline || args.evidence) && isString(value);
 }
 
 export function decodeReadValue(args, value) {
-  const sniffed = isRoutingPayload(value);
+  // Decode only by requested mode, never by fields inside literal host text.
+  if (!decodeByArgs(args, value)) return value;
 
-  if (!sniffed && !decodeByArgs(args, value)) return value;
-
-  try {
-    const parsed = JSON.parse(value);
-
-    return sniffed && !isRoutingObject(parsed) ? value : parsed;
-  } catch (error) {
-    if (sniffed && !decodeByArgs(args, value)) return value;
-
-    throw jsonReadError(args, error);
-  }
+  try { return JSON.parse(value); }
+  catch (error) { throw jsonReadError(args, error); }
 }
 
 function jsonReadError(args, error) {

package/src/fs/background.js

@@ -36,6 +36,14 @@ function wake(job) {
   for (const notify of job.waiters) notify();
 }
 
+// Decoded streams contain complete pairs, but retention/cursor slicing may
+// land on a low surrogate. Deliver only the next complete code point.
+function completeCharacterStart(text, index) {
+  const code = text.charCodeAt(index);
+
+  return code >= 0xdc00 && code <= 0xdfff ? index + 1 : index;
+}
+
 function appendOutput(job, chunk) {
   job.total += chunk.length;
   job.output = (job.output + chunk).slice(-OUTPUT_CHARS);
@@ -45,12 +53,12 @@ function appendOutput(job, chunk) {
 function snapshot(job, cursor = 0) {
   if (cursor > job.total) throw new Error("terminal cursor is beyond available output");
   const start = job.total - job.output.length;
-  const outputStart = Math.max(start, cursor);
+  const outputStart = start + completeCharacterStart(job.output, Math.max(0, cursor - start));
 
   const result = {
     sessionId:job.id, pid:job.child.pid, status:job.status, pty:job.pty,
     exitCode:job.exitCode, signal:job.signal, outputStart, cursor:job.total,
-    truncated:cursor < start, output:job.output.slice(outputStart-start),
+    truncated:cursor < outputStart, output:job.output.slice(outputStart-start),
   };
 
   if (job.error) result.error = job.error;