pi-repl-py 0.6.6 → 0.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-repl-py",
-	"version": "0.6.6",
+	"version": "0.6.7",
 	"type": "module",
 	"description": "A pi extension with a single tool: execute, running a TypeScript host with a persistent Python (ipykernel) evaluator and a user-configurable toolbox of functions.",
 	"keywords": [

package/src/engine/index.ts

@@ -20,12 +20,12 @@ function resolvePythonPath(_cwd: string | undefined): string {
 	return process.env.PYTHON ?? "python3";
 }
 
-const DEFAULT_MAX_OUTPUT_CHARS = 65536;
+const DEFAULT_MAX_OUTPUT_CHARS = 46080;
 /** Per-line cap: one genuinely oversized line must not own the channel budget, while legitimately long
  * REPL output (JSON, reprs, errors) still fits under the cap in one piece. Generous enough that only
  * pathological giant lines are trimmed, unlike pi's grep where the line cap keeps matches terse. */
 export const MAX_OUTPUT_LINE_CHARS = 4096;
-const ABORT_GRACE_MS = 500;
+const ABORT_GRACE_MS = 20_000;
 const DEFAULT_SNAPSHOT_DEBOUNCE_MS = 1500;
 
 interface EngineExecuteError {
@@ -50,7 +50,7 @@ export interface ExecuteOptions {
 	/** Aborting cancels the cell via kernel interrupt; the namespace is preserved. */
 	signal?: AbortSignal;
 	onStream?: (chunk: string, name: "stdout" | "stderr") => void;
-	/** Cap stdout / stderr / result at this many characters. Default 65536. */
+	/** Cap stdout / stderr / result at this many characters. Default 45K. */
 	maxOutputChars?: number;
 }
 

package/src/extension/helpers.ts

@@ -38,9 +38,10 @@ function loadHelperEntries(dir?: string): HelperEntry[] {
 
 /** The prompt-facing list, one bullet per loaded file (verbatim description, or an introspection pointer). */
 export function buildHelpersMap(dir?: string): string[] {
+	// pi renders each prompt guideline as "- <line>"; these lines are bare, no bullet prefix.
 	return loadHelperEntries(dir).map((t) =>
 		t.description
-			? `- ${t.description.replace(/\n/g, "\n  ")}`
-			: `- ${t.name} (no description, inspect it with print(${t.name}.__doc__))`,
+			? t.description.replace(/\n/g, "\n  ")
+			: `${t.name} (no description, inspect it with print(${t.name}.__doc__))`,
 	);
 }

package/src/extension/prompt.ts

@@ -1,52 +1,23 @@
-// --- execute tool: the model-facing contract + workspace doctrine (pure, no pi/helper dep) ---
+// --- execute tool: the model-facing contract, shaped exactly like pi's built-in tools ---
+// description = rich short behavior; promptSnippet = one-liner; guidelines = flat bullets.
 
 export const executeToolDescription =
-	"Execute Python cells in a persistent ipython kernel; state survives across cells and turns, replacing " +
-	"the default read, bash, edit, write, and search tools. Let a cell's returned value prove the work, " +
-	"not prose restating it.";
+	"Execute Python cells in a persistent Python shell that is your entire workspace: it is where you read, " +
+	"write, run, and move, all in one instrument. The state you build, files, and subprocesses survive " +
+	"from one call to the next. Returns stdout, stderr, and the value of the last expression. Output is " +
+	"truncated to 45K with a marker.";
 
-export const executePromptSnippet =
-	"Execute Python cells in a persistent ipython kernel (replaces read, bash, edit, write, and search; state survives across cells and turns)";
+export const executePromptSnippet = "Execute Python in a persistent shell (read, write, run, search, and more)";
 
-// --- the workspace doctrine riding the execute tool ---
+// --- the model-facing guidelines, flat bullets like pi's own tool contributions ---
 export function buildPromptGuidelines(preloaded: string[]): string[] {
 	return [
-		"## Your only workspace",
-		"You are an engineer in a persistent Python REPL. `execute` is the only callable surface, it replaces read, bash, edit, write, and search. What you define (variables, functions, imports) survives across cells and turns, so define any function once and call it in later cells. The work is proven by the result each cell returns, and by nothing else.",
-		"",
-		"## Reason, then say, then stop",
-		"Reason inside the cell, not the transcript: do the thinking in variables and filters, return only the outcome. End on an assignment, a bare expression auto-prints. Keep the reasoning you need, drop the rest, the returned result is the evidence of the work, not the words around it.",
-		"",
-		"## The environment answers you",
-		"The cell's output is the ground truth, what actually ran, what errored, what came back. Trust it over any narrative: if a cell already proved it, point at that. When you're unsure what a fetch contains, read a slice, don't guess and don't dump it whole to 'check'.",
-		"",
-		"## Gather, slice, decide",
-		"Fetch into a variable, never into the transcript. Search results, reads, command output, file contents, assign. A bare expression prints, so end those cells on the assignment. Then advance on a bounded slice: print only the fragment that decides the next step, hold the rest in the variable, peel into the pieces you need without re-fetching, and when the reasoning lands, print the conclusion.",
-		"",
-		"Reading whole is fine when the task needs all of it, hold it and reason on it; the point isn't to never read fully, it's to not re-fetch the same big thing twice.",
-		"",
-		"## Output format",
-		"In reply text: the conclusion and the handful of results that prove it, the slice you acted on, the returned value, a one-line takeaway. Do not transcribe the run, restate every variable, or narrate what the cell already showed.",
-		"",
-		"## Edits and repo discipline",
-		"Surgical old-text/new-text: read the region, fix an exact unique anchor that appears once, replace, verify. Many small edits over one big rewrite, a parse error can strand an anchor; after an error, read the file back from disk first. Make the smallest valid change, preserve conventions, never invent files, APIs, conventions, or test results. Prune generated dirs when walking trees. Pass a `timeout` to any `subprocess.run(...)`, a silent cell must die, not hang.",
-		"",
-		"## Print is expensive",
-		"Every token you print is spent from the context you need for the turns to come, and it never comes back. Treat printing as debt, not reward. Print only the exact fragment the next decision consumes and hold the whole in a variable. Every other print is waste, it buys nothing and closes the room you have left to think. Ask before you print: does this decide the next step, or is it just noise? When it is noise, cut it. When in doubt, cut it. A tight transcript is the sign you actually worked; a bloated one is the sign you did not.",
-		"",
-		...(preloaded.length
-			? [
-					"## Helpers",
-					"These helpers are already defined in the workspace namespace. Use them by name as you would any other loaded function, class, or variable. Their code already executed at kernel boot. Descriptions appear below.",
-					"",
-					...preloaded,
-					"",
-				]
-			: []),
-		"## Environment & rescue",
-		"The evaluator runs in a project-local venv, not the system Python. Do not install a project's dependencies into the evaluator; run external projects through their own interface. If output begins with `<repl_engine_reset>`, the kernel rebuilt, re-verify a revived variable before reusing it.",
-		"",
-		"## These rules are the surface",
-		"The rules above are the surface of how this workspace works, not the whole of it. Internalize their intent, apply it to cases they don't mention, and follow them diligently.",
+		"State persists across cells, so define a function once and keep building on it.",
+		"Find, filter, fetch, read: narrow the output in Python, then print the exact slice you need.",
+		"Keep the result in a variable and reuse it, instead of re-fetching the same thing.",
+		"Make surgical, precise changes over rewrites or whole-file dumps: a small unique anchor, replace, verify, read the file back before trusting it.",
+		"The evaluator runs in a project-local venv. Do not install a project's dependencies into it; run external projects through their own interface. If output begins with <repl_engine_reset>, the kernel rebuilt; re-verify a revived variable.",
+		...(preloaded.length ? ["Preloaded helpers, use them as any loaded function or variable:", ...preloaded] : []),
+		"Be concise.",
 	];
 }