@mku1tra/que-pasa 0.2.1 → 0.2.3

package/README.md

@@ -51,7 +51,7 @@ Install it from npm: `npm install @mku1tra/que-pasa zod`. zod is a peer dependen
 
 ## Release
 
-Set the version in `package.json`, commit, land, and push its tag, `v<version>`. `.github/workflows/publish.yml` runs the check set and publishes on npm by trusted publishing (no token, with provenance). A ruleset lets only an admin of the repo make a version tag. A version npm has is not published again. A published version cannot change: npm unpublishes only within 72 hours.
+A land is a version when its commits ask for one: crate reads their types (Conventional Commits) on the server, tags main `v<version>`, and copies the tag to GitHub ([crate](https://github.com/matta-kelly/crate#release)). While que-pasa is at 0.x, a breaking change bumps minor, and `feat`, `fix` and `perf` bump patch. `.github/workflows/publish.yml` runs the check set, sets `package.json`'s version from the tag, and publishes on npm by trusted publishing (no token, with provenance). `package.json`'s version in git is not kept: the tag is the version. A ruleset lets only crate's deploy key, or an admin of the repo, make a version tag. A version npm has is not published again. A published version cannot change: npm unpublishes only within 72 hours.
 
 ## Ship
 

package/dist/sandbox/backend.d.ts

@@ -66,7 +66,7 @@ export interface FileBackend {
     edit(path: string, old: string, next: string, all: boolean): Promise<EditResult>;
     /** The files under a folder whose path from that folder matches a glob. */
     glob(pattern: string, path: string): Promise<GlobResult>;
-    /** The lines of the files under a path that hold a text, as is (not a pattern), in files matching `glob` if given. */
+    /** The lines of the files under a path that hold a text, as is (not a pattern), in files matching `glob` if given: by path, then line. */
     grep(pattern: string, path: string, glob?: string): Promise<GrepResult>;
 }
 /** Files, and commands: a backend that can run a shell command. */

package/dist/sandbox/index.d.ts

@@ -3,5 +3,5 @@ export { local } from "./local.ts";
 export { podman, type Mount, type Podman, type PodmanOptions, } from "./podman.ts";
 export { shellBackend, type Exec } from "./shell.ts";
 export type { Ran, Script } from "./process.ts";
-export { Sandbox, edit_file, execute, fileTools, glob, grep, ls, read_file, readTools, write_file, } from "./tools.ts";
+export { Sandbox, commandAnswer, edit_file, execute, fileTools, glob, grep, ls, maxAnswer, read_file, readTools, write_file, } from "./tools.ts";
 export { view, type ViewPaths } from "./view.ts";

package/dist/sandbox/index.js

@@ -2,5 +2,5 @@ export { canExecute, } from "./backend.js";
 export { local } from "./local.js";
 export { podman, } from "./podman.js";
 export { shellBackend } from "./shell.js";
-export { Sandbox, edit_file, execute, fileTools, glob, grep, ls, read_file, readTools, write_file, } from "./tools.js";
+export { Sandbox, commandAnswer, edit_file, execute, fileTools, glob, grep, ls, maxAnswer, read_file, readTools, write_file, } from "./tools.js";
 export { view } from "./view.js";

package/dist/sandbox/shell.js

@@ -157,6 +157,8 @@ else exit ${missing}; fi`,
             const files = glob ? await matching(at, glob) : await filesUnder(at);
             if (!files)
                 return { error: "file_not_found" };
+            // By path, then line, as glob lists them: the same order on any file system.
+            files.sort();
             // No line holds a newline, so a text with one is in no file.
             if (pattern.includes("\n"))
                 return { matches: [] };

package/dist/sandbox/tools.d.ts

@@ -5,7 +5,7 @@
  */
 import { z } from "zod";
 import { type Json } from "../define/index.ts";
-import { type FileBackend } from "./backend.ts";
+import { type ExecuteResult, type FileBackend } from "./backend.ts";
 /** The backend a run's file tools work in: the host provides it per run, such as a container, or a view over one. */
 export declare const Sandbox: import("../define/resource.ts").Resource<FileBackend>;
 /** The most of a tool's answer the model gets (Deep Agents: 20,000 tokens, at four characters each). */
@@ -40,6 +40,11 @@ export declare const grep: import("../define/tool.ts").Tool<z.ZodObject<{
 export declare const execute: import("../define/tool.ts").Tool<z.ZodObject<{
     command: z.ZodString;
 }, z.core.$strip>, Json | undefined>;
+/**
+ * What the model reads for a command that ran: the tail of its output, at most `maxAnswer` characters, where a failure
+ * is, then how it ended. `execute`'s answer, for a host tool that runs a command to answer the same way.
+ */
+export declare function commandAnswer(result: ExecuteResult): string;
 /** The tools that only read. */
 export declare const readTools: readonly [import("../define/tool.ts").Tool<z.ZodObject<{
     path: z.ZodDefault<z.ZodString>;

package/dist/sandbox/tools.js

@@ -5,7 +5,7 @@
  */
 import { z } from "zod";
 import { defineResource, defineTool, } from "../define/index.js";
-import { canExecute } from "./backend.js";
+import { canExecute, } from "./backend.js";
 /** The backend a run's file tools work in: the host provides it per run, such as a container, or a view over one. */
 export const Sandbox = defineResource("sandbox");
 /** The most of a tool's answer the model gets (Deep Agents: 20,000 tokens, at four characters each). */
@@ -224,18 +224,24 @@ export const execute = defineTool({
         if (!canExecute(backend)) {
             return "Error: Execution not available. This agent's backend does not support command execution.";
         }
-        const result = await backend.execute(command);
-        const cutTail = result.output.length > maxAnswer;
-        const output = cutTail ? result.output.slice(-maxAnswer) : result.output;
-        const status = result.exitCode === null
-            ? "[Command was killed]"
-            : `[Command ${result.exitCode === 0 ? "succeeded" : "failed"} with exit code ${result.exitCode}]`;
-        const truncated = result.truncated || cutTail
-            ? "\n[Output was truncated due to size limits]"
-            : "";
-        return `${output}${output.endsWith("\n") || output === "" ? "" : "\n"}${status}${truncated}`;
+        return commandAnswer(await backend.execute(command));
     },
 });
+/**
+ * What the model reads for a command that ran: the tail of its output, at most `maxAnswer` characters, where a failure
+ * is, then how it ended. `execute`'s answer, for a host tool that runs a command to answer the same way.
+ */
+export function commandAnswer(result) {
+    const cutTail = result.output.length > maxAnswer;
+    const output = cutTail ? result.output.slice(-maxAnswer) : result.output;
+    const status = result.exitCode === null
+        ? "[Command was killed]"
+        : `[Command ${result.exitCode === 0 ? "succeeded" : "failed"} with exit code ${result.exitCode}]`;
+    const truncated = result.truncated || cutTail
+        ? "\n[Output was truncated due to size limits]"
+        : "";
+    return `${output}${output.endsWith("\n") || output === "" ? "" : "\n"}${status}${truncated}`;
+}
 /** The tools that only read. */
 export const readTools = [ls, read_file, glob, grep];
 /** The tools that read and write files. `execute` is given on its own. */

package/dist/sandbox/view.js

@@ -1,4 +1,3 @@
-import { posix } from "node:path";
 import { fromRoot, isUnder } from "./paths.js";
 /**
  * A backend over a backend, limited to some files: to its tools, a path outside the view does not exist, and a write
@@ -18,32 +17,15 @@ export function view(backend, paths) {
     });
     const writes = new Set(checked(paths.write));
     const files = [...new Set([...checked(paths.read), ...writes])];
+    const mine = new Set(files);
     /** A path of the view: one of its files, or a folder on the way to one. */
     const sees = (at) => files.some((f) => f === at || isUnder(f, at));
     /** A path the view resolves, or undefined when it is outside the root. */
     const at = (path) => fromRoot(root, path);
     const missing = { error: "file_not_found" };
     const invalid = { error: "invalid_path" };
-    /** The view's files under a folder whose path from it matches a glob: its own list, never the folder's. */
-    const under = (folder, glob) => files.filter((f) => {
-        // A search leaves out .git, as a backend's does.
-        if (!isUnder(f, folder) || f.split("/").includes(".git"))
-            return false;
-        const from = f === folder
-            ? posix.basename(f)
-            : folder
-                ? f.slice(folder.length + 1)
-                : f;
-        return glob === undefined || posix.matchesGlob(from, glob);
-    });
-    /** Which of the files are there: a write file can be one not made yet. */
-    const present = async (list) => {
-        const there = await Promise.all(list.map(async (f) => {
-            const listed = await backend.ls(f);
-            return listed.files?.some((e) => e.path === f && !e.isDir) ?? false;
-        }));
-        return list.filter((_, i) => there[i]);
-    };
+    /** A path the backend gave back that is one of the view's files. */
+    const own = (path) => mine.has(path);
     const refused = (path) => ({
         error: "permission_denied",
         message: `${path} is not a file this view may write: it may write ${[...writes].join(", ") || "none"}`,
@@ -79,13 +61,16 @@ export function view(backend, paths) {
                 return invalid;
             return writes.has(p) ? backend.edit(path, old, next, all) : refused(path);
         },
+        // A search runs once on the backend, and the view keeps its own files: Deep Agents filters its path rules' results
+        // the same way. The backend's limit counts files outside the view too, so a cut result says it is cut.
         async glob(pattern, path) {
             const p = at(path);
             if (p === undefined)
                 return invalid;
             if (!sees(p))
                 return missing;
-            return { files: (await present(under(p, pattern))).sort() };
+            const found = await backend.glob(pattern, path);
+            return found.files ? { ...found, files: found.files.filter(own) } : found;
         },
         async grep(pattern, path, glob) {
             const p = at(path);
@@ -93,13 +78,10 @@ export function view(backend, paths) {
                 return invalid;
             if (!sees(p))
                 return missing;
-            // Each of its files on its own, so files outside the view are never read.
-            const matches = [];
-            for (const f of (await present(under(p, glob))).sort()) {
-                const found = await backend.grep(pattern, f);
-                matches.push(...(found.matches ?? []));
-            }
-            return { matches };
+            const found = await backend.grep(pattern, path, glob);
+            return found.matches
+                ? { ...found, matches: found.matches.filter((m) => own(m.path)) }
+                : found;
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mku1tra/que-pasa",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "An agent harness on pi-durable: define agents and tools with define/, and run them durably and traced with loop/.",
   "license": "MIT",
   "repository": {