pi-supernova 0.3.2 → 0.5.0

package/src/context/surface.js

@@ -3,9 +3,11 @@ import { isString } from "../shared/decode.js";
 
 function scanPython(lines) {
   const items = [];
+
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     const match = /^([ \t]*)(def|class|async def)\s+([a-zA-Z0-9_]+)(\(.*?\))?:?/.exec(line);
+
     if (!match) continue;
     items.push({
       kind: match[2].includes("def") ? "function" : "class",
@@ -15,14 +17,17 @@ function scanPython(lines) {
       depth: Math.floor(match[1].length / 4),
     });
   }
+
   return items;
 }
 
 function scanRust(lines) {
   const items = [];
+
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
     const match = /^(pub\s+)?(async\s+)?(fn|struct|enum|trait|impl|type|const)\s+([a-zA-Z0-9_]+)(<.*?>)?(\(.*?\))?/.exec(line);
+
     if (!match) continue;
     items.push({
       kind: match[3],
@@ -31,14 +36,17 @@ function scanRust(lines) {
       line: i + 1,
     });
   }
+
   return items;
 }
 
 function scanGo(lines) {
   const items = [];
+
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
     const funcMatch = /^func\s+(\(.*?\)\s+)?([a-zA-Z0-9_]+)(\(.*?\))/.exec(line);
+
     if (funcMatch) {
       items.push({
         kind: "function",
@@ -48,7 +56,9 @@ function scanGo(lines) {
       });
       continue;
     }
+
     const typeMatch = /^type\s+([a-zA-Z0-9_]+)\s+(struct|interface)/.exec(line);
+
     if (typeMatch) {
       items.push({
         kind: typeMatch[2],
@@ -58,6 +68,7 @@ function scanGo(lines) {
       });
     }
   }
+
   return items;
 }
 
@@ -66,37 +77,52 @@ const JS_DECL_PATTERNS = [
   [/^(?:async\s+)?(function\*?|class)\s+([a-zA-Z0-9_$]+)/, false],
   [/^(interface|type)\s+([a-zA-Z0-9_$]+)/, false],
 ];
+
 // Module-level tables/constants (column 0 only): without them the previous declaration's span swallows them.
 const JS_TOP_LEVEL_BINDING = /^(const|let|var)\s+([a-zA-Z0-9_$]+)\s*=/;
-// Indented methods (object-literal adapters, class members) that open a block on the same line.
-const JS_METHOD = /^(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?\*?([a-zA-Z_$][\w$]*)\s*\([^()]*\)\s*\{$/;
-const JS_ARROW_PROPERTY = /^([a-zA-Z_$][\w$]*)\s*[:=]\s*(?:async\s+)?(?:\([^()]*\)|[a-zA-Z_$][\w$]*)\s*=>\s*\{$/;
+
+// Indented methods (object-literal adapters, class members), including one-liners.
+const JS_METHOD = /^(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?\*?([a-zA-Z_$][\w$]*)\s*\([^()]*\)\s*\{/;
+
+const JS_ARROW_PROPERTY = /^([a-zA-Z_$][\w$]*)\s*[:=]\s*(?:async\s+)?(?:\([^()]*\)|[a-zA-Z_$][\w$]*)\s*=>\s*\{/;
+
 const NOT_METHOD_NAMES = new Set(["if", "for", "while", "switch", "catch", "function", "return", "else", "do", "try", "with", "await", "typeof", "new", "constructor"]);
 
 function methodItem(line, lineNumber, depth) {
   const match = JS_METHOD.exec(line) || JS_ARROW_PROPERTY.exec(line);
+
   if (!match || NOT_METHOD_NAMES.has(match[1])) return null;
-  return { kind: "method", name: match[1], isExport: false, signature: line.replace(/\s*\{$/, ""), line: lineNumber, depth };
+
+  return { kind: "method", name: match[1], isExport: false, signature: line.replace(/\s*\{.*$/, "").trim(), line: lineNumber, depth };
 }
 
 function declarationItem(line, rawLine, lineNumber) {
+  const indent = rawLine.length - rawLine.trimStart().length;
+  const depth = Math.floor(indent / 2);
   const patterns = /^\S/.test(rawLine) ? [...JS_DECL_PATTERNS, [JS_TOP_LEVEL_BINDING, false]] : JS_DECL_PATTERNS;
+
   for (const [pattern, isExport] of patterns) {
     const match = pattern.exec(line);
-    if (match) return { kind: match[1], name: match[2], isExport, signature: line.replace(/\{.*$/, "").trim(), line: lineNumber, depth: 0 };
+
+    if (match) return { kind: match[1], name: match[2], isExport, signature: line.replace(/\{.*$/, "").trim(), line: lineNumber, depth };
   }
+
   return null;
 }
 
 function scanJavaScript(lines) {
   const items = [];
+
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
+
     if (!line || line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) continue;
     const indent = lines[i].length - lines[i].trimStart().length;
-    const item = declarationItem(line, lines[i], i + 1) || (indent > 0 && indent <= 8 ? methodItem(line, i + 1, 1) : null);
+    const item = declarationItem(line, lines[i], i + 1) || (indent > 0 && indent <= 8 ? methodItem(line, i + 1, Math.max(1, Math.floor(indent / 2))) : null);
+
     if (item) items.push(item);
   }
+
   return items;
 }
 
@@ -118,5 +144,6 @@ export function extractStructuralSurface(code, extension = "js") {
   const ext = extension.replace(/^\./, "").toLowerCase();
   const scanner = SCANNERS[ext] || SCANNERS.js;
   const items = scanner(lines);
+
   return { items, lineCount: lines.length };
 }

package/src/fs/check.js

@@ -3,7 +3,9 @@
 // on, so a broken edit is known now instead of after a test run. JSON is checked exactly.
 
 const OPEN = { "{": "}", "[": "]", "(": ")" };
+
 const CLOSE = new Set(["}", "]", ")"]);
+
 const REGEX_PRECEDERS = new Set(["(", ",", "=", ":", "[", "!", "&", "|", "?", "{", "}", ";", "+", "-", "*", "%", "<", ">", "~", "^", "return", "typeof", "case", "do", "else", "in", "of"]);
 
 function skipString(text, i, quote) {
@@ -12,9 +14,12 @@ function skipString(text, i, quote) {
       j++;
       continue;
     }
+
     if (text[j] === quote) return j + 1;
+
     if (quote !== "`" && text[j] === "\n") return -1;
   }
+
   return -1;
 }
 
@@ -24,13 +29,17 @@ function skipTemplate(text, i, stack) {
       j++;
       continue;
     }
+
     if (text[j] === "`") return j + 1;
+
     if (text[j] === "$" && text[j + 1] === "{") {
       const end = balancedEnd(text, j + 1, stack);
+
       if (end < 0) return -1;
       j = end - 1; // loop increment lands on the char after "}"
     }
   }
+
   return -1;
 }
 
@@ -38,67 +47,90 @@ function skipTemplate(text, i, stack) {
 function balancedEnd(text, i, stack) {
   const depth = stack.length;
   const r = scan(text, i, stack, depth);
+
   return r.error ? -1 : r.end;
 }
 
 function skipComment(text, i) {
   if (text[i + 1] === "/") {
     const nl = text.indexOf("\n", i);
+
     return nl < 0 ? text.length : nl;
   }
+
   const end = text.indexOf("*/", i + 2);
+
   return end < 0 ? text.length : end + 2;
 }
 
 function skipRegex(text, i) {
   let inClass = false;
+
   for (let j = i + 1; j < text.length; j++) {
     const c = text[j];
+
     if (c === "\\") {
       j++;
       continue;
     }
+
     if (c === "\n") return -1;
+
     if (c === "[") inClass = true;
     else if (c === "]") inClass = false;
     else if (c === "/" && !inClass) return j + 1;
   }
+
   return -1;
 }
 
 function lineOf(text, i) {
   let n = 1;
+
   for (let j = 0; j < i && j < text.length; j++) if (text[j] === "\n") n++;
+
   return n;
 }
 
 const IDENT_START = /[A-Za-z_$]/;
+
 const IDENT_PART = /[\w$]/;
 
 function readIdentifier(text, i) {
   let j = i + 1;
+
   while (j < text.length && IDENT_PART.test(text[j])) j++;
+
   return j;
 }
 
 function consumeQuoted(text, i, stack) {
   const c = text[i];
+
   if (c === "`") {
     const end = skipTemplate(text, i, stack);
+
     return end < 0 ? { error: "unterminated template literal", at: i } : { end, prev: "value" };
   }
+
   const end = skipString(text, i, c);
+
   return end < 0 ? { error: "unterminated string", at: i } : { end, prev: "value" };
 }
 
 /** Try to consume a comment, string, template, or regex at i. Returns { end, prev } | { error, at } | null. */
 function consumeLiteral(text, i, stack, prev) {
   const c = text[i];
+
   if (c === '"' || c === "'" || c === "`") return consumeQuoted(text, i, stack);
+
   if (c !== "/") return null;
+
   if (text[i + 1] === "/" || text[i + 1] === "*") return { end: skipComment(text, i), prev };
+
   if (prev !== "" && !REGEX_PRECEDERS.has(prev)) return null;
   const end = skipRegex(text, i);
+
   return end > 0 ? { end, prev: "value" } : null;
 }
 
@@ -106,12 +138,17 @@ function consumeLiteral(text, i, stack, prev) {
 function bracket(c, i, stack, stopDepth) {
   if (OPEN[c]) {
     stack.push({ c, at: i });
+
     return null;
   }
+
   if (!CLOSE.has(c)) return null;
   const top = stack.pop();
+
   if (!top || OPEN[top.c] !== c) return { error: "unexpected '" + c + "'", at: i };
+
   if (stopDepth !== undefined && stack.length <= stopDepth) return { end: i + 1 };
+
   return null;
 }
 
@@ -119,26 +156,33 @@ function bracket(c, i, stack, stopDepth) {
 function scan(text, start, stack, stopDepth) {
   let i = start;
   let prev = "";
+
   while (i < text.length) {
     const c = text[i];
     const literal = consumeLiteral(text, i, stack, prev);
+
     if (literal) {
       if (literal.error) return literal;
       i = literal.end;
       prev = literal.prev;
       continue;
     }
+
     if (IDENT_START.test(c)) {
       const j = readIdentifier(text, i);
       prev = text.slice(i, j);
       i = j;
       continue;
     }
+
     const outcome = bracket(c, i, stack, stopDepth);
+
     if (outcome) return outcome;
+
     if (!/\s/.test(c)) prev = c;
     i++;
   }
+
   return { end: i };
 }
 
@@ -149,18 +193,24 @@ export function quickCheck(text, ext) {
   if (ext === ".json") {
     try {
       JSON.parse(text);
+
       return { ok: true, kind: "json" };
     } catch (err) {
       return { ok: false, kind: "json", message: String(err.message).replace(/^JSON\.parse: /, "") };
     }
   }
+
   if (!CODE_EXT.has(ext)) return null;
   const stack = [];
   const r = scan(text, 0, stack);
+
   if (r.error) return { ok: false, kind: "balance", message: r.error + " at line " + lineOf(text, r.at) };
+
   if (stack.length) {
     const top = stack[stack.length - 1];
+
     return { ok: false, kind: "balance", message: "unclosed '" + top.c + "' opened at line " + lineOf(text, top.at) };
   }
+
   return { ok: true, kind: "balance" };
 }

package/src/fs/diff.js

@@ -10,6 +10,7 @@ export function buildEditDiff(filePath, originalText, oldText, newText) {
   const newLines = contentLines(newText);
 
   const lines = [];
+
   if (startLine > 1 && fileLines.length >= startLine - 1) {
     lines.push({ type: "context", lineNum: startLine - 1, text: fileLines[startLine - 2] });
   }
@@ -17,11 +18,13 @@ export function buildEditDiff(filePath, originalText, oldText, newText) {
   for (let i = 0; i < oldLines.length; i++) {
     lines.push({ type: "remove", lineNum: startLine + i, text: oldLines[i] });
   }
+
   for (let i = 0; i < newLines.length; i++) {
     lines.push({ type: "add", lineNum: startLine + i, text: newLines[i] });
   }
 
   const afterSourceLine = startLine + oldLines.length;
+
   if (fileLines.length >= afterSourceLine) {
     lines.push({ type: "context", lineNum: startLine + newLines.length, text: fileLines[afterSourceLine - 1] });
   }
@@ -39,16 +42,20 @@ export function buildMultiEditDiff(filePath, originalText, replacements) {
   const parts = replacements.map(({ oldText, newText }) =>
     buildEditDiff(filePath, originalText, oldText, newText),
   );
+
   const lines = [];
   let shift = 0;
+
   for (const [index, part] of parts.entries()) {
     for (const line of part.lines) {
       if (line.type === "context") continue;
       lines.push(line.type === "add" ? { ...line, lineNum: line.lineNum + shift }
         : { ...line, newLineNum: Math.max(1, line.lineNum + shift) });
     }
+
     shift += replacements[index].newText.split("\n").length - replacements[index].oldText.split("\n").length;
   }
+
   return {
     path: filePath,
     op: "edit",
@@ -75,6 +82,7 @@ export function buildPatchDiff(filePath, patchText) {
 
   for (const patchLine of patchLines) {
     const headerMatch = (/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?/).exec(patchLine);
+
     if (headerMatch) {
       // A zero-length range names the line before the insertion/deletion point.
       oldLineNum = Number(headerMatch[1]) + Number(headerMatch[2] === "0");
@@ -82,9 +90,12 @@ export function buildPatchDiff(filePath, patchText) {
       inHunk = true;
       continue;
     }
+
     if (!inHunk || patchLine.startsWith("\\")) continue;
     const kind = classifyPatchLine(patchLine);
+
     if (!kind) continue;
+
     if (kind === "remove") {
       removed += 1;
       lines.push({ type: "remove", lineNum: oldLineNum, newLineNum, text: patchLine.slice(1) });
@@ -106,7 +117,9 @@ export function buildPatchDiff(filePath, patchText) {
 function contentLines(text) {
   if (!isString(text) || text.length === 0) return [];
   const lines = text.replace(/\r\n/g, "\n").split("\n");
+
   if (lines.at(-1) === "") lines.pop();
+
   return lines;
 }
 
@@ -115,12 +128,15 @@ export function buildWriteDiff(filePath, previousText, newText) {
   const oldLines = contentLines(previousText);
   const maxStoredLines = 64;
   const lines = [];
+
   for (let i = 0; i < oldLines.length && lines.length < maxStoredLines; i++) {
     lines.push({ type: "remove", lineNum: i + 1, text: oldLines[i] });
   }
+
   for (let i = 0; i < newLines.length && lines.length < maxStoredLines; i++) {
     lines.push({ type: "add", lineNum: i + 1, text: newLines[i] });
   }
+
   return {
     path: filePath,
     op: "write",

package/src/fs/json-read.js

@@ -0,0 +1,91 @@
+import { isString, isObject } from "../shared/decode.js";
+
+export const MAX_JSON_BYTES = 16 * 1024 * 1024;
+
+const SELECTOR_HELP = 'JSON selector supports .field, .nested[0], .items[0:3], .["quoted.key"], or . (whole value); not full jq';
+
+/** Parse a small, non-evaluating selector language. No dynamic code or prototype lookup. */
+function parseSelector(selector) {
+  if (!isString(selector) || !selector.startsWith(".") || selector.length > 2048) throw new Error(SELECTOR_HELP);
+  let rest = selector.slice(1);
+  const steps = [];
+  let first = true;
+
+  while (rest) {
+    let match;
+
+    if ((match = (first ? /^([A-Za-z_$][\w$]*)/ : /^\.([A-Za-z_$][\w$]*)/).exec(rest))) {
+      steps.push({ key: match[1] });
+    } else if ((match = /^\[("(?:[^"\\]|\\.)*")\]/.exec(rest))) {
+      try { steps.push({ key: JSON.parse(match[1]) }); } catch { throw new Error(SELECTOR_HELP); }
+    } else if ((match = /^\[(\d+)(?::(\d+))?\]/.exec(rest))) {
+      const start = Number(match[1]), end = match[2] === undefined ? undefined : Number(match[2]);
+
+      if (!Number.isSafeInteger(start) || (end !== undefined && (!Number.isSafeInteger(end) || end < start))) throw new Error(SELECTOR_HELP);
+      steps.push(end === undefined ? { index: start } : { start, end });
+    } else throw new Error(SELECTOR_HELP);
+    rest = rest.slice(match[0].length);
+    first = false;
+  }
+
+  return steps;
+}
+
+export function jsonProjector(json) {
+  const many = Array.isArray(json);
+  const selectors = many ? json : [json === true ? "." : json];
+
+  if (!selectors.length || selectors.length > 64) throw new Error("JSON selector list requires 1 to 64 selectors");
+  const plans = Array.from(selectors, parseSelector);
+
+  // Yield one selection at a time so the caller can budget it before the next
+  // slice allocation. Eagerly mapping 64 large slices can exhaust the host heap.
+  return function* (root) {
+    for (const steps of plans) yield steps.reduce((value, step) => {
+      if (step.key !== undefined) {
+        if (!isObject(value) || !Object.hasOwn(value, step.key)) {
+          const keys = isObject(value) ? Object.keys(value) : [];
+          const preview = keys.length ? "; available keys: " + keys.slice(0, 24).map(key => JSON.stringify(key)).join(", ") + (keys.length > 24 ? ", …" : "") : "";
+          throw new Error("JSON field not found: " + JSON.stringify(step.key) + preview);
+        }
+
+        return value[step.key];
+      }
+
+      if (!Array.isArray(value)) throw new Error("JSON index requires an array");
+
+      if (step.index !== undefined) {
+        if (step.index >= value.length) throw new Error("JSON index out of range: " + step.index);
+
+        return value[step.index];
+      }
+
+      return value.slice(step.start, step.end);
+    }, root);
+  };
+}
+
+export function sessionJsonArgs(args) {
+  if (!isString(args.path) || !/^(agent|artifact):\/\//i.test(args.path) || !args.path.includes("?")) return args;
+  const [uri, query] = args.path.split("?");
+  const params = new URLSearchParams(query);
+
+  if (args.path.includes("#") || args.path.split("?").length !== 2 || params.size !== 1 || !params.has("q") || args.json !== undefined) {
+    throw new Error("session resource supports only one ?q=<JSON selector>; do not combine it with json");
+  }
+
+  const json = params.get("q");
+  jsonProjector(json); // Reject invalid selectors before artifact lookup.
+
+  return { ...args, path: uri, json };
+}
+
+export function validateJsonRead(args) {
+  if (args.json === undefined) return;
+
+  if (["offset", "limit", "about", "query", "outline", "evidence", "resolve", "complete"].some(key => args[key] !== undefined)) {
+    throw new Error("JSON reads cannot combine json with line windows, source views, or complete; select fields after parsing the whole document");
+  }
+
+  jsonProjector(args.json);
+}

package/src/fs/patch.js

@@ -2,7 +2,9 @@ import { isString } from "../shared/decode.js";
 
 function parseHunkHeader(line) {
   const match = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/.exec(line);
+
   if (!match) return null;
+
   return { oldStart: Number(match[1]), oldLength: match[2] === undefined ? 1 : Number(match[2]),
     newStart: Number(match[3]), newLength: match[4] === undefined ? 1 : Number(match[4]), lines: [], noNewline: [] };
 }
@@ -12,8 +14,10 @@ export function parsePatchHunks(patchText) {
   let current;
   let oldCount = 0;
   let newCount = 0;
+
   for (const line of patchText.split("\n")) {
     const header = parseHunkHeader(line);
+
     if (header) {
       current = header;
       hunks.push(current);
@@ -26,12 +30,17 @@ export function parsePatchHunks(patchText) {
       if (oldCount === current.oldLength && newCount === current.newLength && /^--- |^\+\+\+ /.test(line)) {
         throw new Error("apply_patch accepts one file at a time");
       }
+
       current.lines.push(line);
+
       if (line[0] !== "+") oldCount++;
+
       if (line[0] !== "-") newCount++;
     }
   }
+
   if (!hunks.length) throw new Error("no valid patch hunks found (expected @@ -old,len +new,len @@)");
+
   return hunks;
 }
 
@@ -39,10 +48,13 @@ function splitFile(text) {
   if (!text) return [];
   const chunks = text.split("\n");
   const trailing = chunks.at(-1) === "";
+
   if (trailing) chunks.pop();
+
   return chunks.map((chunk, index) => {
     const newline = index < chunks.length - 1 || trailing;
     const crlf = newline && chunk.endsWith("\r");
+
     return { text: crlf ? chunk.slice(0, -1) : chunk, ending: newline ? (crlf ? "\r\n" : "\n") : "" };
   });
 }
@@ -50,12 +62,17 @@ function splitFile(text) {
 function findHunkMatch(fileLines, expectedOld, nominal) {
   const matchAt = index => index >= 0 && index + expectedOld.length <= fileLines.length
     && expectedOld.every((line, i) => fileLines[index + i].text === line);
+
   if (matchAt(nominal)) return nominal;
+
   if (!expectedOld.length) return -1;
+
   for (let delta = 1; delta <= Math.max(fileLines.length, 100); delta++) {
     if (matchAt(nominal + delta)) return nominal + delta;
+
     if (matchAt(nominal - delta)) return nominal - delta;
   }
+
   return -1;
 }
 
@@ -66,31 +83,40 @@ export function applyPatchToText(originalText, patchText) {
   const ending = fileLines.find(line => line.ending)?.ending ?? "\n";
   let offsetShift = 0;
   let relocationShift = 0;
+
   for (let h = 0; h < hunks.length; h++) {
     const hunk = hunks[h];
     const textOf = line => line.slice(1).replace(/\r$/, "");
     const expectedOld = hunk.lines.filter(line => line[0] !== "+").map(textOf);
     const newCount = hunk.lines.filter(line => line[0] !== "-").length;
+
     if (expectedOld.length !== hunk.oldLength || newCount !== hunk.newLength) throw new Error("patch hunk " + (h + 1) + " length does not match its header");
     // The new coordinate also handles BSD diff's -1,0 header at file start.
     const nominal = hunk.oldLength === 0 ? hunk.newStart - 1 + relocationShift : hunk.oldStart - 1 + offsetShift;
     const matchIndex = findHunkMatch(fileLines, expectedOld, nominal);
+
     if (matchIndex < 0) throw new Error("patch hunk " + (h + 1) + " rejected at line " + hunk.oldStart + ": context did not match");
     const replacement = [];
     let oldIndex = matchIndex;
+
     for (let i = 0; i < hunk.lines.length; i++) {
       const line = hunk.lines[i];
+
       if (line[0] === "+") {
         replacement.push({ text: textOf(line), ending: hunk.noNewline.includes(i) ? "" : line.endsWith("\r") ? "\r\n" : ending });
       } else {
         const original = fileLines[oldIndex++];
+
         if (hunk.noNewline.includes(i) && original.ending) throw new Error("patch newline marker does not match the file");
+
         if (line[0] === " ") replacement.push(original);
       }
     }
+
     fileLines.splice(matchIndex, expectedOld.length, ...replacement);
     relocationShift += matchIndex - nominal;
     offsetShift += matchIndex - nominal + replacement.length - expectedOld.length;
   }
+
   return { resultText: fileLines.map(line => line.text + line.ending).join(""), hunkCount: hunks.length };
 }