@oh-my-pi/pi-coding-agent 13.19.0 → 14.0.2

package/src/config/prompt-templates.ts

@@ -1,12 +1,17 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getProjectDir, getProjectPromptsDir, getPromptsDir, logger } from "@oh-my-pi/pi-utils";
-import Handlebars from "handlebars";
-import { computeLineHash } from "../patch/hashline";
+import { type ChunkAnchorStyle, formatAnchor } from "@oh-my-pi/pi-natives";
+import {
+	getProjectDir,
+	getProjectPromptsDir,
+	getPromptsDir,
+	logger,
+	parseFrontmatter,
+	prompt,
+} from "@oh-my-pi/pi-utils";
+import { computeLineHash } from "../edit/line-hash";
 import { jtdToTypeScript } from "../tools/jtd-to-typescript";
 import { parseCommandArgs, substituteArgs } from "../utils/command-args";
-import { parseFrontmatter } from "../utils/frontmatter";
-import { formatPromptContent } from "../utils/prompt-format";
 
 /**
  * Represents a prompt template loaded from a markdown file
@@ -18,215 +23,7 @@ export interface PromptTemplate {
 	source: string; // e.g., "(user)", "(project)", "(project:frontend)"
 }
 
-export interface TemplateContext extends Record<string, unknown> {
-	args?: string[];
-	ARGUMENTS?: string;
-	arguments?: string;
-}
-
-const handlebars = Handlebars.create();
-
-handlebars.registerHelper("arg", function (this: TemplateContext, index: number | string): string {
-	const args = this.args ?? [];
-	const parsedIndex = typeof index === "number" ? index : Number.parseInt(index, 10);
-	if (!Number.isFinite(parsedIndex)) return "";
-	const zeroBased = parsedIndex - 1;
-	if (zeroBased < 0) return "";
-	return args[zeroBased] ?? "";
-});
-
-/**
- * {{#list items prefix="- " suffix="" join="\n"}}{{this}}{{/list}}
- * Renders an array with customizable prefix, suffix, and join separator.
- * Note: Use \n in join for newlines (will be unescaped automatically).
- */
-handlebars.registerHelper(
-	"list",
-	function (this: unknown, context: unknown[], options: Handlebars.HelperOptions): string {
-		if (!Array.isArray(context) || context.length === 0) return "";
-		const prefix = (options.hash.prefix as string) ?? "";
-		const suffix = (options.hash.suffix as string) ?? "";
-		const rawSeparator = (options.hash.join as string) ?? "\n";
-		const separator = rawSeparator.replace(/\\n/g, "\n").replace(/\\t/g, "\t");
-		return context.map(item => `${prefix}${options.fn(item)}${suffix}`).join(separator);
-	},
-);
-
-/**
- * {{join array ", "}}
- * Joins an array with a separator (default: ", ").
- */
-handlebars.registerHelper("join", (context: unknown[], separator?: unknown): string => {
-	if (!Array.isArray(context)) return "";
-	const sep = typeof separator === "string" ? separator : ", ";
-	return context.join(sep);
-});
-
-/**
- * {{default value "fallback"}}
- * Returns the value if truthy, otherwise returns the fallback.
- */
-handlebars.registerHelper("default", (value: unknown, defaultValue: unknown): unknown => value || defaultValue);
-
-/**
- * {{pluralize count "item" "items"}}
- * Returns "1 item" or "5 items" based on count.
- */
-handlebars.registerHelper(
-	"pluralize",
-	(count: number, singular: string, plural: string): string => `${count} ${count === 1 ? singular : plural}`,
-);
-
-/**
- * {{#when value "==" compare}}...{{else}}...{{/when}}
- * Conditional block with comparison operators: ==, ===, !=, !==, >, <, >=, <=
- */
-handlebars.registerHelper(
-	"when",
-	function (this: unknown, lhs: unknown, operator: string, rhs: unknown, options: Handlebars.HelperOptions): string {
-		const ops: Record<string, (a: unknown, b: unknown) => boolean> = {
-			"==": (a, b) => a === b,
-			"===": (a, b) => a === b,
-			"!=": (a, b) => a !== b,
-			"!==": (a, b) => a !== b,
-			">": (a, b) => (a as number) > (b as number),
-			"<": (a, b) => (a as number) < (b as number),
-			">=": (a, b) => (a as number) >= (b as number),
-			"<=": (a, b) => (a as number) <= (b as number),
-		};
-		const fn = ops[operator];
-		if (!fn) return options.inverse(this);
-		return fn(lhs, rhs) ? options.fn(this) : options.inverse(this);
-	},
-);
-
-/**
- * {{#ifAny a b c}}...{{else}}...{{/ifAny}}
- * True if any argument is truthy.
- */
-handlebars.registerHelper("ifAny", function (this: unknown, ...args: unknown[]): string {
-	const options = args.pop() as Handlebars.HelperOptions;
-	return args.some(Boolean) ? options.fn(this) : options.inverse(this);
-});
-
-/**
- * {{#ifAll a b c}}...{{else}}...{{/ifAll}}
- * True if all arguments are truthy.
- */
-handlebars.registerHelper("ifAll", function (this: unknown, ...args: unknown[]): string {
-	const options = args.pop() as Handlebars.HelperOptions;
-	return args.every(Boolean) ? options.fn(this) : options.inverse(this);
-});
-
-/**
- * {{#table rows headers="Col1|Col2"}}{{col1}}|{{col2}}{{/table}}
- * Generates a markdown table from an array of objects.
- */
-handlebars.registerHelper(
-	"table",
-	function (this: unknown, context: unknown[], options: Handlebars.HelperOptions): string {
-		if (!Array.isArray(context) || context.length === 0) return "";
-		const headersStr = options.hash.headers as string | undefined;
-		const headers = headersStr?.split("|") ?? [];
-		const separator = headers.map(() => "---").join(" | ");
-		const headerRow = headers.length > 0 ? `| ${headers.join(" | ")} |\n| ${separator} |\n` : "";
-		const rows = context.map(item => `| ${options.fn(item).trim()} |`).join("\n");
-		return headerRow + rows;
-	},
-);
-
-/**
- * {{#codeblock lang="diff"}}...{{/codeblock}}
- * Wraps content in a fenced code block.
- */
-handlebars.registerHelper("codeblock", function (this: unknown, options: Handlebars.HelperOptions): string {
-	const lang = (options.hash.lang as string) ?? "";
-	const content = options.fn(this).trim();
-	return `\`\`\`${lang}\n${content}\n\`\`\``;
-});
-
-/**
- * {{#xml "tag"}}content{{/xml}}
- * Wraps content in XML-style tags. Returns empty string if content is empty.
- */
-handlebars.registerHelper("xml", function (this: unknown, tag: string, options: Handlebars.HelperOptions): string {
-	const content = options.fn(this).trim();
-	if (!content) return "";
-	return `<${tag}>\n${content}\n</${tag}>`;
-});
-
-/**
- * {{escapeXml value}}
- * Escapes XML special characters: & < > "
- */
-handlebars.registerHelper("escapeXml", (value: unknown): string => {
-	if (value == null) return "";
-	return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-});
-
-/**
- * {{len array}}
- * Returns the length of an array or string.
- */
-handlebars.registerHelper("len", (value: unknown): number => {
-	if (Array.isArray(value)) return value.length;
-	if (typeof value === "string") return value.length;
-	return 0;
-});
-
-/**
- * {{add a b}}
- * Adds two numbers.
- */
-handlebars.registerHelper("add", (a: number, b: number): number => (a ?? 0) + (b ?? 0));
-
-/**
- * {{sub a b}}
- * Subtracts b from a.
- */
-handlebars.registerHelper("sub", (a: number, b: number): number => (a ?? 0) - (b ?? 0));
-
-/**
- * {{#has collection item}}...{{else}}...{{/has}}
- * Checks if an array includes an item or if a Set/Map has a key.
- */
-handlebars.registerHelper(
-	"has",
-	function (this: unknown, collection: unknown, item: unknown, options: Handlebars.HelperOptions): string {
-		let found = false;
-		if (Array.isArray(collection)) {
-			found = collection.includes(item);
-		} else if (collection instanceof Set) {
-			found = collection.has(item);
-		} else if (collection instanceof Map) {
-			found = collection.has(item);
-		} else if (collection && typeof collection === "object") {
-			if (typeof item === "string" || typeof item === "number" || typeof item === "symbol") {
-				found = item in collection;
-			}
-		}
-		return found ? options.fn(this) : options.inverse(this);
-	},
-);
-
-/**
- * {{includes array item}}
- * Returns true if array includes item. For use in other helpers.
- */
-handlebars.registerHelper("includes", (collection: unknown, item: unknown): boolean => {
-	if (Array.isArray(collection)) return collection.includes(item);
-	if (collection instanceof Set) return collection.has(item);
-	if (collection instanceof Map) return collection.has(item);
-	return false;
-});
-
-/**
- * {{not value}}
- * Returns logical NOT of value. For use in subexpressions.
- */
-handlebars.registerHelper("not", (value: unknown): boolean => !value);
-
-handlebars.registerHelper("jtdToTypeScript", (schema: unknown): string => {
+prompt.registerHelper("jtdToTypeScript", (schema: unknown): string => {
 	try {
 		return jtdToTypeScript(schema);
 	} catch {
@@ -234,8 +31,6 @@ handlebars.registerHelper("jtdToTypeScript", (schema: unknown): string => {
 	}
 });
 
-handlebars.registerHelper("jsonStringify", (value: unknown): string => JSON.stringify(value));
-
 /**
  * Renders a section separator:
  *
@@ -247,7 +42,7 @@ export function sectionSeparator(name: string): string {
 	return `\n\n═══════════${name}═══════════\n`;
 }
 
-handlebars.registerHelper("SECTION_SEPERATOR", (name: unknown): string => sectionSeparator(String(name)));
+prompt.registerHelper("SECTION_SEPERATOR", (name: unknown): string => sectionSeparator(String(name)));
 
 function formatHashlineRef(lineNum: unknown, content: unknown): { num: number; text: string; ref: string } {
 	const num = typeof lineNum === "number" ? lineNum : Number.parseInt(String(lineNum), 10);
@@ -261,7 +56,7 @@ function formatHashlineRef(lineNum: unknown, content: unknown): { num: number; t
  * {{href lineNum "content"}} — compute a real hashline ref for prompt examples.
  * Returns `"lineNum#hash"` using the actual hash algorithm.
  */
-handlebars.registerHelper("href", (lineNum: unknown, content: unknown): string => {
+prompt.registerHelper("href", (lineNum: unknown, content: unknown): string => {
 	const { ref } = formatHashlineRef(lineNum, content);
 	return JSON.stringify(ref);
 });
@@ -270,11 +65,40 @@ handlebars.registerHelper("href", (lineNum: unknown, content: unknown): string =
  * {{hline lineNum "content"}} — format a full read-style line with prefix.
  * Returns `"lineNum#hash:content"`.
  */
-handlebars.registerHelper("hline", (lineNum: unknown, content: unknown): string => {
+prompt.registerHelper("hline", (lineNum: unknown, content: unknown): string => {
 	const { ref, text } = formatHashlineRef(lineNum, content);
 	return `${ref}:${text}`;
 });
 
+/**
+ * {{anchor name checksum}} — render a branch anchor tag using the current anchor style.
+ * Style is resolved from the template context (`anchorStyle`) or defaults to "full".
+ */
+prompt.registerHelper("anchor", function (this: prompt.TemplateContext, name: string, checksum: string): string {
+	const style = (this.anchorStyle as ChunkAnchorStyle) ?? "full";
+	return formatAnchor(name, checksum, style);
+});
+
+/**
+ * {{sel "parent_Name.child_Name"}} — render a chunk path for `sel` fields in examples.
+ * In `full` style the path is returned as-is (`class_Server.fn_start`).
+ * In `kind` style each segment is trimmed to its kind prefix (`class.fn`).
+ * In `bare` style the path is omitted (the model uses only `crc` to identify chunks).
+ */
+prompt.registerHelper("sel", function (this: prompt.TemplateContext, chunkPath: string): string {
+	const style = (this.anchorStyle as ChunkAnchorStyle) ?? "full";
+	if (style === "full") return chunkPath;
+	if (style === "bare") return "";
+	// kind: trim each segment to its kind prefix (before the first `_`)
+	return chunkPath
+		.split(".")
+		.map(seg => {
+			const idx = seg.indexOf("_");
+			return idx === -1 ? seg : seg.slice(0, idx);
+		})
+		.join(".");
+});
+
 const INLINE_ARG_SHELL_PATTERN = /\$(?:ARGUMENTS|@(?:\[\d+(?::\d*)?\])?|\d+)/;
 const INLINE_ARG_TEMPLATE_PATTERN = /\{\{[\s\S]*?(?:\b(?:arguments|ARGUMENTS|args)\b|\barg\s+[^}]+)[\s\S]*?\}\}/;
 
@@ -297,12 +121,6 @@ export function appendInlineArgsFallback(
 	return `${rendered}\n\n${argsText}`;
 }
 
-export function renderPromptTemplate(template: string, context: TemplateContext = {}): string {
-	const compiled = handlebars.compile(template, { noEscape: true, strict: false });
-	const rendered = compiled(context ?? {});
-	return formatPromptContent(rendered, { renderPhase: "post-render" });
-}
-
 /**
  * Recursively scan a directory for .md files (and symlinks to .md files) and load them as prompt templates
  */
@@ -429,7 +247,7 @@ export function expandPromptTemplate(text: string, templates: PromptTemplate[]):
 		const argsText = args.join(" ");
 		const usesInlineArgPlaceholders = templateUsesInlineArgPlaceholders(template.content);
 		const substituted = substituteArgs(template.content, args);
-		const rendered = renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
+		const rendered = prompt.render(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
 		return appendInlineArgsFallback(rendered, argsText, usesInlineArgPlaceholders);
 	}
 

package/src/config/resolve-config-value.ts

@@ -55,8 +55,10 @@ async function executeCommand(commandConfig: string): Promise<string | undefined
 async function runShellCommand(command: string, timeoutMs: number): Promise<string | undefined> {
 	try {
 		let output = "";
-		const result = await executeShell({ command, timeoutMs }, chunk => {
-			output += chunk;
+		const result = await executeShell({ command, timeoutMs }, (err, chunk) => {
+			if (!err) {
+				output += chunk;
+			}
 		});
 		if (result.timedOut || result.exitCode !== 0) {
 			return undefined;

package/src/config/settings-schema.ts

@@ -949,12 +949,12 @@ export const SETTINGS_SCHEMA = {
 	// Edit tool
 	"edit.mode": {
 		type: "enum",
-		values: ["replace", "patch", "hashline"] as const,
+		values: ["replace", "patch", "hashline", "chunk"] as const,
 		default: "hashline",
 		ui: {
 			tab: "editing",
 			label: "Edit Mode",
-			description: "Select the edit tool variant (replace, patch, or hashline)",
+			description: "Select the edit tool variant (replace, patch, hashline, or chunk)",
 		},
 	},
 
@@ -1030,6 +1030,38 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"read.prosechunks": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "editing",
+			label: "Prose Chunks",
+			description: "Enable chunk rendering for prose files in chunk edit mode",
+		},
+	},
+
+	"read.explorechunks": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "editing",
+			label: "Explore Chunks",
+			description: "Show chunk tree without checksums for read-only agents like explore",
+		},
+	},
+
+	"read.anchorstyle": {
+		type: "enum",
+		values: ["full", "kind", "bare"],
+		default: "full",
+		ui: {
+			tab: "editing",
+			label: "Anchor Style",
+			description: "Render chunk anchors with full names, kind prefixes, or checksum-only tags",
+			submenu: true,
+		},
+	},
+
 	// LSP
 	"lsp.enabled": {
 		type: "boolean",
@@ -1214,6 +1246,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"debug.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tools",
+			label: "Debug",
+			description: "Enable the debug tool for DAP-based debugging",
+		},
+	},
+
 	"calc.enabled": {
 		type: "boolean",
 		default: false,
@@ -1642,6 +1684,16 @@ export const SETTINGS_SCHEMA = {
 
 	"commit.changelogMaxDiffChars": { type: "number", default: 120000 },
 
+	"dev.autoqa": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "Auto QA",
+			description: "Enable automated tool issue reporting (report_tool_issue) for all agents",
+		},
+	},
+
 	"thinkingBudgets.minimal": { type: "number", default: 1024 },
 
 	"thinkingBudgets.low": { type: "number", default: 2048 },

package/src/config/settings.ts

@@ -13,22 +13,15 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import {
-	getAgentDbPath,
-	getAgentDir,
-	getProjectDir,
-	isEnoent,
-	logger,
-	procmgr,
-	setDefaultTabWidth,
-} from "@oh-my-pi/pi-utils";
+import { setDefaultTabWidth } from "@oh-my-pi/pi-natives";
+import { getAgentDbPath, getAgentDir, getProjectDir, isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { type Settings as SettingsCapabilityItem, settingsCapability } from "../capability/settings";
 import type { ModelRole } from "../config/model-registry";
 import { loadCapability } from "../discovery";
 import { isLightTheme, setAutoThemeMapping, setColorBlindMode, setSymbolPreset } from "../modes/theme/theme";
-import { type EditMode, normalizeEditMode } from "../patch";
 import { AgentStorage } from "../session/agent-storage";
+import { type EditMode, normalizeEditMode } from "../utils/edit-mode";
 import { withFileLock } from "./file-lock";
 import {
 	type BashInterceptorRule,
@@ -68,15 +61,6 @@ export interface SettingsOptions {
 // Path Utilities
 // ═══════════════════════════════════════════════════════════════════════════
 
-/**
- * Parse a dotted path into segments.
- * "compaction.enabled" → ["compaction", "enabled"]
- * "theme.dark" → ["theme", "dark"]
- */
-function parsePath(path: string): string[] {
-	return path.split(".");
-}
-
 /**
  * Get a nested value from an object by path segments.
  */
@@ -144,7 +128,7 @@ export class Settings {
 
 		if (options.overrides) {
 			for (const [key, value] of Object.entries(options.overrides)) {
-				setByPath(this.#overrides, parsePath(key), value);
+				setByPath(this.#overrides, key.split("."), value);
 			}
 		}
 	}
@@ -207,7 +191,7 @@ export class Settings {
 	 * Returns the merged value from global + project + overrides, or the default.
 	 */
 	get<P extends SettingPath>(path: P): SettingValue<P> {
-		const segments = parsePath(path);
+		const segments = path.split(".");
 		const value = getByPath(this.#merged, segments);
 		if (value !== undefined) {
 			return value as SettingValue<P>;
@@ -222,7 +206,7 @@ export class Settings {
 	 */
 	set<P extends SettingPath>(path: P, value: SettingValue<P>): void {
 		const prev = this.get(path);
-		const segments = parsePath(path);
+		const segments = path.split(".");
 		setByPath(this.#global, segments, value);
 		this.#modified.add(path);
 		this.#rebuildMerged();
@@ -239,7 +223,7 @@ export class Settings {
 	 * Apply runtime overrides (not persisted).
 	 */
 	override<P extends SettingPath>(path: P, value: SettingValue<P>): void {
-		const segments = parsePath(path);
+		const segments = path.split(".");
 		setByPath(this.#overrides, segments, value);
 		this.#rebuildMerged();
 	}
@@ -248,7 +232,7 @@ export class Settings {
 	 * Clear a runtime override.
 	 */
 	clearOverride(path: SettingPath): void {
-		const segments = parsePath(path);
+		const segments = path.split(".");
 		let current = this.#overrides;
 		for (let i = 0; i < segments.length - 1; i++) {
 			const segment = segments[i];
@@ -276,6 +260,21 @@ export class Settings {
 		}
 	}
 
+	async cloneForCwd(cwd: string): Promise<Settings> {
+		const cloned = new Settings({
+			cwd,
+			agentDir: this.#agentDir,
+			inMemory: !this.#persist,
+		});
+		cloned.#storage = this.#storage;
+		cloned.#global = structuredClone(this.#global);
+		cloned.#project = this.#persist ? await cloned.#loadProjectSettings() : structuredClone(this.#project);
+		cloned.#overrides = structuredClone(this.#overrides);
+		cloned.#rebuildMerged();
+		cloned.#fireAllHooks();
+		return cloned;
+	}
+
 	// ─────────────────────────────────────────────────────────────────────────
 	// Accessors
 	// ─────────────────────────────────────────────────────────────────────────
@@ -320,7 +319,7 @@ export class Settings {
 
 	/**
 	 * Get the edit variant for a specific model.
-	 * Returns "patch", "replace", "hashline", or null (use global default).
+	 * Returns "patch", "replace", "hashline", "chunk", or null (use global default).
 	 */
 	getEditVariantForModel(model: string | undefined): EditMode | null {
 		if (!model) return null;
@@ -562,7 +561,7 @@ export class Settings {
 
 				// Apply only our modified paths
 				for (const modPath of modifiedPaths) {
-					const segments = parsePath(modPath);
+					const segments = modPath.split(".");
 					const value = getByPath(this.#global, segments);
 					setByPath(current, segments, value);
 				}