pi-supernova 0.3.1 → 0.4.0

package/src/bridge/native-tools.js

@@ -14,6 +14,7 @@ export const NATIVE_NAMES = Object.freeze(["read", "edit", "write", "bash"]);
 function userPath(cwd, input) {
   if (!isString(input) || !input.trim()) throw new Error("path must be a non-empty string");
   const value = input.trim().replace(/^@/, "");
+
   return path.resolve(cwd, value === "~" ? homedir() : value.startsWith("~/") ? path.join(homedir(), value.slice(2)) : value);
 }
 
@@ -22,15 +23,20 @@ function boundText(result, maxChars) {
   const truncated = total > maxChars;
   const notice = truncated ? truncateChars("\n[Truncated: read files individually or narrow the line range/question.]", maxChars, "read-result").text : "";
   let remaining = maxChars - notice.length;
+
   const content = result.content.map(block => {
     if (block.type !== "text") return block; // Images remain image attachments.
     const bounded = truncateChars(block.text, remaining, "read-result");
     remaining -= bounded.text.length;
+
     return { ...block, text: bounded.text };
   });
+
   if (notice) content.push({ type: "text", text: notice });
   const details = { ...result.details };
+
   if (truncated) details.outputTruncated = true;
+
   return { ...result, content, details };
 }
 
@@ -39,6 +45,7 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
   let cwd = process.cwd();
   const base = createHostBridge({ pi: null, config: { ...config, seenWindow: 0 }, getCwd: () => cwd });
   const scheduler = createNativeScheduler();
+
   const factories = {
     read: host.createReadToolDefinition,
     edit: host.createEditToolDefinition,
@@ -53,15 +60,19 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
   async function readOne(args, signal, ctx, bridge, id) {
     const target = userPath(ctx.cwd, args.path);
     let stat;
+
     try { stat = await fs.stat(target); }
     catch (error) { if (error.code !== "ENOENT" && error.code !== "ENOTDIR") throw error; }
+
     signal?.throwIfAborted();
     const image = /\.(png|jpe?g|gif|webp|bmp)$/i.test(target);
+
     if (stat?.isFile() && (args.about === undefined || image)) {
       // Pi retains image handling, full text, line windows, truncation metadata,
       // and actionable continuation offsets. Do not summarize or dedupe these.
       return factories.read(ctx.cwd, { autoResizeImages: image ? settingsFor(ctx)?.getImageAutoResize() : undefined }).execute(id, { ...args, path: target }, signal, undefined, ctx);
     }
+
     return boundText(await bridge.natives.read({ ...args, path: stat ? target : args.path }, signal), config.maxCallResultChars);
   }
 
@@ -70,69 +81,90 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
     const bridge = base.fork({ getCwd: () => ctx.cwd });
     bridge.bindCallContext(ctx, signal);
     signal?.throwIfAborted();
+
     try {
       if (name === "read") {
         if (!Array.isArray(args.path)) return await readOne(args, signal, ctx, bridge, id);
+
         if (args.path.some(p => !isString(p) || !p.trim())) throw new Error("read paths must be non-empty strings");
+
         if (args.path.length > 64) throw new Error("read path arrays support at most 64 entries; use smaller batches");
         const groups = [], errors = [];
+
         // Bound fan-out even when a model submits a large path array.
         for (let offset = 0; offset < args.path.length; offset += 8) {
           const results = await Promise.all(args.path.slice(offset, offset + 8).map(async file => {
             try {
               const result = await readOne({ ...args, path: file }, signal, ctx, bridge, id);
+
               return { content: [{ type: "text", text: "File: " + file }, ...result.content] };
             } catch (error) {
               signal?.throwIfAborted();
               errors.push({ path: file, message: error.message });
+
               return { content: [{ type: "text", text: "[read error: " + file + "] " + error.message }] };
             }
           }));
+
           groups.push(...results);
         }
+
         const content = [];
         let remaining = config.maxCallResultChars, outputTruncated = false;
+
         for (let i = 0; i < groups.length; i++) {
           const bounded = boundText(groups[i], Math.floor(remaining / (groups.length - i)));
           remaining -= bounded.content.reduce((sum, block) => sum + (block.type === "text" ? block.text.length : 0), 0);
           outputTruncated ||= bounded.details.outputTruncated === true;
           content.push(...bounded.content);
         }
+
         return { content, details: { batch: true, count: args.path.length, errors, outputTruncated } };
       }
+
       if (name === "bash") {
         const settings = settingsFor(ctx);
+
         try { return await factories.bash(ctx.cwd, { shellPath: settings?.getShellPath(), commandPrefix: settings?.getShellCommandPrefix() }).execute(id, args, signal, onUpdate, ctx); }
         finally { bridge.invalidateFiles(); }
       }
+
       clearPathCache();
       const target = await resolveWorkspacePath(ctx.cwd, userPath(ctx.cwd, args.path), name);
       const ops = bridge.fileOperations;
       let before, after;
+
       const tool = factories[name](ctx.cwd, { operations: {
         ...ops,
-        async readFile(file) { const buffer = await ops.readFile(file); before = buffer.toString("utf8"); return buffer; },
+        async readFile(file) { const buffer = await ops.readFile(file); before = buffer.toString("utf8");
+
+ return buffer; },
         async writeFile(file, content) { await ops.writeFile(file, content); after = content; },
       } });
+
       // Pi's edit/write implementations hold its shared canonical per-file queue
       // over the entire mutation, including our atomic replacement operation.
       const result = await tool.execute(id, { ...args, path: target }, signal, onUpdate, ctx);
+
       if (name === "edit" && before !== undefined && after !== undefined && result.details?.patch) {
         const summary = await bridge.summarizeEdit(target, before, after, buildPatchDiff(target, result.details.patch));
         result.content = [{ type: "text", text: summary }];
       }
+
       return result;
     } finally { bridge.close(); }
   }
 
   for (const name of NATIVE_NAMES) {
     const definition = factories[name](cwd);
+
     const tool = {
       ...definition,
       execute(id, args, signal, onUpdate, ctx) {
         return scheduler.schedule(name, () => execute(name, id, args, signal, onUpdate, ctx), signal);
       },
     };
+
     if (name === "read") {
       tool.description += " Also reads directories or finds source from a symbol/question passed as path. Use about to focus a file or directory on a question. An array of paths returns all readable files and labels individual errors.";
       tool.parameters = { ...definition.parameters, properties: {
@@ -142,8 +174,10 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
       } };
       tool.promptGuidelines = [...(definition.promptGuidelines || []), "read can find source from a symbol or question; check its selection status before choosing a file. Plain file reads preserve full text within the stated limits."];
     }
+
     pi.registerTool(tool);
   }
+
   pi.on("session_start", (_event, ctx) => {
     cwd = ctx?.cwd || cwd;
     base.invalidateFiles();

package/src/config/config.default.json

@@ -5,7 +5,7 @@
   "maxCallResultChars": 65536,
   "maxReturnChars": 32000,
   "maxHeapMb": 512,
-  "seenWindow": 40,
+  "seenWindow": 0,
   "maxLogLines": 100,
   "maxLogLineChars": 4096,
   "maxSearchResults": 12,

package/src/config/config.js

@@ -5,10 +5,13 @@ import { createRequire } from "node:module";
 import { isString, isObject } from "../shared/decode.js";
 
 const require = createRequire(import.meta.url);
+
 const DEFAULTS = require("./config.default.json");
 
 const KNOWN_KEYS = new Set(Object.keys(DEFAULTS));
+
 const NONNEGATIVE_INTEGER_KEYS = new Set(["maxLogLines", "seenWindow"]);
+
 const POSITIVE_INTEGER_KEYS = new Set([
   "timeoutMs",
   "maxCodeChars",
@@ -28,11 +31,15 @@ const VALIDATORS = {
 };
 
 const KEY_VALIDATOR = new Map();
+
 for (const k of POSITIVE_INTEGER_KEYS) KEY_VALIDATOR.set(k, VALIDATORS.positiveInt);
+
 for (const k of NONNEGATIVE_INTEGER_KEYS) KEY_VALIDATOR.set(k, VALIDATORS.nonNegativeInt);
+
 for (const k of Object.keys(DEFAULTS)) {
   if (Array.isArray(DEFAULTS[k])) KEY_VALIDATOR.set(k, VALIDATORS.stringArray);
 }
+
 KEY_VALIDATOR.set("spillDir", VALIDATORS.spillDir);
 
 export function packageDefaults() {
@@ -41,21 +48,28 @@ export function packageDefaults() {
 
 function userConfigPath() {
   if (process.env.PI_SUPERNOVA_CONFIG) return process.env.PI_SUPERNOVA_CONFIG;
+
   for (const key of ["PI_CONFIG_DIR", "OMP_CONFIG_DIR"]) {
     const root = process.env[key];
+
     if (!root || !isString(root)) continue;
+
     return path.join(path.resolve(root), "agent", "supernova.json");
   }
+
   const install = import.meta.dirname ?? path.dirname(new URL(import.meta.url).pathname);
   const norm = String(install).replace(/\\/g, "/").toLowerCase();
   const home = os.homedir();
+
   if (norm.includes("/.omp/")) return path.join(home, ".omp", "agent", "supernova.json");
+
   return path.join(home, ".pi", "agent", "supernova.json");
 }
 
 function readJson(filePath) {
   try {
     const text = fs.readFileSync(filePath, "utf8");
+
     return JSON.parse(text);
   } catch (err) {
     if (err && (err.code === "ENOENT" || err.code === "ENOTDIR")) return null;
@@ -66,18 +80,23 @@ function readJson(filePath) {
 export function mergeConfig(base, overlay) {
   if (!overlay || !isObject(overlay) || Array.isArray(overlay)) return base;
   const out = { ...base };
+
   for (const [key, value] of Object.entries(overlay)) {
     if (!KNOWN_KEYS.has(key)) continue;
     const validate = KEY_VALIDATOR.get(key);
+
     if (!validate) continue;
+
     if (validate(value)) out[key] = Array.isArray(value) ? value.slice() : value;
   }
+
   return out;
 }
 
 export function loadConfig() {
   const userPath = userConfigPath();
   const user = readJson(userPath);
+
   return mergeConfig(packageDefaults(), user ?? null);
 }