@oh-my-pi/pi-coding-agent 16.1.22 → 16.2.0

package/src/dap/config.ts

@@ -1,11 +1,38 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
-import { isRecord } from "@oh-my-pi/pi-utils";
+import { isRecord, logger } from "@oh-my-pi/pi-utils";
+import { YAML } from "bun";
+import { getConfigDirPaths } from "../config";
+import { getPreloadedPluginRoots } from "../discovery/helpers";
 import { hasRootMarkers, resolveCommand } from "../lsp/config";
 import DEFAULTS from "./defaults.json" with { type: "json" };
 import type { DapAdapterConfig, DapResolvedAdapter } from "./types";
 
 const EXTENSIONLESS_DEBUGGER_ORDER = ["gdb", "lldb-dap"] as const;
 
+interface NormalizedConfig {
+	adapters: Record<string, unknown>;
+}
+
+interface ConfigSource {
+	read(): NormalizedConfig | null;
+}
+
+function parseConfigContent(content: string, filePath: string): unknown {
+	const extension = path.extname(filePath).toLowerCase();
+	if (extension === ".yaml" || extension === ".yml") {
+		return YAML.parse(content) as unknown;
+	}
+	return JSON.parse(content) as unknown;
+}
+
+function normalizeConfig(value: unknown): NormalizedConfig | null {
+	if (!isRecord(value)) return null;
+	if (isRecord(value.adapters)) return { adapters: value.adapters };
+	return { adapters: value };
+}
+
 function normalizeStringArray(value: unknown): string[] {
 	if (!Array.isArray(value)) return [];
 	return value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
@@ -32,6 +59,15 @@ function normalizeAdapterConfig(config: unknown): DapAdapterConfig | null {
 	};
 }
 
+function readConfigFile(filePath: string): NormalizedConfig | null {
+	try {
+		const content = fs.readFileSync(filePath, "utf-8");
+		return normalizeConfig(parseConfigContent(content, filePath));
+	} catch {
+		return null;
+	}
+}
+
 function getDefaults(): Record<string, DapAdapterConfig> {
 	const adapters: Record<string, DapAdapterConfig> = {};
 	for (const [name, config] of Object.entries(DEFAULTS)) {
@@ -45,14 +81,117 @@ function getDefaults(): Record<string, DapAdapterConfig> {
 
 const DEFAULT_ADAPTERS = getDefaults();
 
-export function getAdapterConfigs(): Record<string, DapAdapterConfig> {
-	return { ...DEFAULT_ADAPTERS };
+function mergeAdapters(
+	base: Record<string, DapAdapterConfig>,
+	overrides: Record<string, unknown>,
+): Record<string, DapAdapterConfig> {
+	const merged: Record<string, DapAdapterConfig> = { ...base };
+	for (const [name, config] of Object.entries(overrides)) {
+		const existing = merged[name];
+		const candidate =
+			isRecord(existing) && isRecord(config)
+				? {
+						...existing,
+						...config,
+						launchDefaults:
+							isRecord(existing.launchDefaults) || isRecord(config.launchDefaults)
+								? { ...existing.launchDefaults, ...normalizeObject(config.launchDefaults) }
+								: undefined,
+						attachDefaults:
+							isRecord(existing.attachDefaults) || isRecord(config.attachDefaults)
+								? { ...existing.attachDefaults, ...normalizeObject(config.attachDefaults) }
+								: undefined,
+					}
+				: config;
+		const normalized = normalizeAdapterConfig(candidate);
+		if (normalized) {
+			merged[name] = normalized;
+		} else if (merged[name]) {
+			logger.warn("Ignoring invalid DAP adapter override (keeping previous config).", { name });
+		} else {
+			logger.warn("Ignoring invalid DAP adapter config.", { name });
+		}
+	}
+	return merged;
 }
 
-export function resolveAdapter(adapterName: string, cwd: string): DapResolvedAdapter | null {
-	const config = DEFAULT_ADAPTERS[adapterName];
+function fileConfigSource(filePath: string): ConfigSource {
+	return {
+		read: () => readConfigFile(filePath),
+	};
+}
+
+function getConfigSources(cwd: string): ConfigSource[] {
+	const filenames = ["dap.json", ".dap.json", "dap.yaml", ".dap.yaml", "dap.yml", ".dap.yml"];
+	const sources: ConfigSource[] = [];
+
+	for (const filename of filenames) {
+		sources.push(fileConfigSource(path.join(cwd, filename)));
+	}
+
+	const projectDirs = getConfigDirPaths("", { user: false, project: true, cwd });
+	for (const dir of projectDirs) {
+		for (const filename of filenames) {
+			sources.push(fileConfigSource(path.join(dir, filename)));
+		}
+	}
+
+	const userDirs = getConfigDirPaths("", { user: true, project: false });
+	for (const dir of userDirs) {
+		for (const filename of filenames) {
+			sources.push(fileConfigSource(path.join(dir, filename)));
+		}
+	}
+
+	const pluginRoots = getPreloadedPluginRoots();
+	for (const root of pluginRoots) {
+		for (const filename of filenames) {
+			sources.push(fileConfigSource(path.join(root.path, filename)));
+		}
+	}
+
+	for (const filename of filenames) {
+		sources.push(fileConfigSource(path.join(os.homedir(), filename)));
+	}
+
+	return sources;
+}
+
+function loadAdapterConfigs(cwd: string): Record<string, DapAdapterConfig> {
+	let adapters = { ...DEFAULT_ADAPTERS };
+	for (const source of getConfigSources(cwd).reverse()) {
+		const parsed = source.read();
+		if (!parsed) continue;
+		adapters = mergeAdapters(adapters, parsed.adapters);
+	}
+	return adapters;
+}
+
+export function getAdapterConfigs(cwd?: string): Record<string, DapAdapterConfig> {
+	return cwd ? loadAdapterConfigs(cwd) : { ...DEFAULT_ADAPTERS };
+}
+
+function normalizeCommandForCwd(command: string, cwd: string): string {
+	if (path.isAbsolute(command)) return command;
+	if (
+		command.startsWith("./") ||
+		command.startsWith("../") ||
+		command.startsWith(".\\") ||
+		command.startsWith("..\\")
+	) {
+		return path.resolve(cwd, command);
+	}
+	return command;
+}
+
+function resolveAdapterFromConfig(
+	adapterName: string,
+	configs: Record<string, DapAdapterConfig>,
+	cwd: string,
+): DapResolvedAdapter | null {
+	const config = configs[adapterName];
 	if (!config) return null;
-	const resolvedCommand = resolveCommand(config.command, cwd);
+	const resolvedCommand = resolveCommand(normalizeCommandForCwd(config.command, cwd), cwd);
 	if (!resolvedCommand) return null;
 	return {
 		name: adapterName,
@@ -69,9 +208,14 @@ export function resolveAdapter(adapterName: string, cwd: string): DapResolvedAda
 	};
 }
 
+export function resolveAdapter(adapterName: string, cwd: string): DapResolvedAdapter | null {
+	return resolveAdapterFromConfig(adapterName, getAdapterConfigs(cwd), cwd);
+}
+
 export function getAvailableAdapters(cwd: string): DapResolvedAdapter[] {
-	return Object.keys(DEFAULT_ADAPTERS)
-		.map(name => resolveAdapter(name, cwd))
+	const configs = getAdapterConfigs(cwd);
+	return Object.keys(configs)
+		.map(name => resolveAdapterFromConfig(name, configs, cwd))
 		.filter((adapter): adapter is DapResolvedAdapter => adapter !== null);
 }
 

package/src/dap/session.ts

@@ -289,7 +289,7 @@ export class DapSessionManager {
 				...(options.extraLaunchArguments ?? {}),
 				program: options.program,
 				cwd: options.cwd,
-				args: options.args,
+				...(options.args !== undefined ? { args: options.args } : {}),
 			};
 			// Subscribe to stop events BEFORE launching so we don't miss
 			// stopOnEntry events that arrive before we start listening.

package/src/discovery/helpers.ts

@@ -18,6 +18,7 @@ import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 import { parseThinkingLevel } from "../thinking";
+import { normalizeToolNames } from "../tools/builtin-names";
 
 import { buildPluginDirRoot } from "./plugin-dir-roots";
 
@@ -246,7 +247,8 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 		return null;
 	}
 
-	let tools = parseArrayOrCSV(frontmatter.tools)?.map(tool => tool.toLowerCase());
+	let tools = parseArrayOrCSV(frontmatter.tools);
+	if (tools) tools = normalizeToolNames(tools);
 
 	// Subagents with explicit tool lists always need yield
 	if (tools && !tools.includes("yield")) {

package/src/edit/hashline/diff.ts

@@ -199,9 +199,15 @@ function buildStreamingSectionDiff(
 	section: PatchSection,
 	normalized: string,
 ): { diff: string; firstChangedLine: number | undefined } | { error: string } {
-	const { edits } = parsePatchStreaming(section.diff);
+	const { edits, fileOp } = parsePatchStreaming(section.diff);
 	const resolved = resolveBlockEdits(edits, normalized, section.path, nativeBlockResolver, { onUnresolved: "drop" });
-	if (resolved.length === 0) return { error: `No changes would be made to ${section.path}.` };
+	if (resolved.length === 0) {
+		// A whole-file op (REM / MV) carries no line edits: the change is the
+		// delete/move itself, conveyed by the result header, so emit an empty
+		// diff rather than a misleading "No changes" error.
+		if (fileOp) return { diff: "", firstChangedLine: undefined };
+		return { error: `No changes would be made to ${section.path}.` };
+	}
 
 	const fileLines = normalized.split("\n");
 	const rows: string[] = [];
@@ -264,7 +270,12 @@ export async function computeHashlineSectionDiff(
 		// (`streaming` unset) falls through to the real Myers diff below.
 		if (options.streaming) return buildStreamingSectionDiff(section, normalized);
 		const result = applyPreviewEdits({ section, absolutePath, normalized, snapshots, options });
-		if (normalized === result.text) return { error: `No changes would be made to ${section.path}.` };
+		if (normalized === result.text) {
+			// REM/MV-only sections change no text; the header conveys the
+			// delete/move, so don't surface a "No changes" error.
+			if (section.fileOp) return { diff: "", firstChangedLine: undefined };
+			return { error: `No changes would be made to ${section.path}.` };
+		}
 		return generateDiffString(normalized, result.text, undefined, { path: section.path });
 	} catch (err) {
 		return { error: err instanceof Error ? err.message : String(err) };

package/src/edit/hashline/execute.ts

@@ -106,7 +106,28 @@ function formatBlockResolution(resolution: BlockResolution): string {
 	return `${op} ${resolution.anchorLine} → resolved ${span} (${lines} line${lines === 1 ? "" : "s"})${suffix}`;
 }
 
-function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsResult | undefined): RenderedSection {
+function renderSection(
+	result: PatchSectionResult,
+	diagnostics: FileDiagnosticsResult | undefined,
+	sourcePath: string,
+): RenderedSection {
+	if (result.op === "delete") {
+		const toolResult: AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema> = {
+			content: [{ type: "text", text: `Deleted ${result.path}` }],
+			details: {
+				diff: "",
+				op: "delete",
+				path: result.path,
+				oldText: result.before,
+				meta: outputMeta().get(),
+			},
+		};
+		return {
+			toolResult,
+			perFileResult: { path: result.path, diff: "", op: "delete", oldText: result.before },
+		};
+	}
+
 	if (result.op === "noop") {
 		const toolResult: AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema> = {
 			content: [{ type: "text", text: noChangeDiagnostic(result.path) }],
@@ -130,24 +151,39 @@ function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsR
 		result.blockResolutions && result.blockResolutions.length > 0
 			? `\n${result.blockResolutions.map(formatBlockResolution).join("\n")}`
 			: "";
+	const moveBlock = result.moveDest ? `\nMoved to ${result.moveDest}` : "";
 	const firstChangedLine = result.firstChangedLine ?? diff.firstChangedLine;
 	return {
 		toolResult: {
-			content: [{ type: "text", text: `${result.header}${blockBlock}${previewBlock}${warningsBlock}` }],
+			content: [
+				{
+					type: "text",
+					text: `${result.header}${blockBlock}${moveBlock}${previewBlock}${warningsBlock}`,
+				},
+			],
 			details: {
 				diff: diff.diff,
 				firstChangedLine,
 				diagnostics,
 				op: result.op,
+				move: result.moveDest,
+				path: result.moveDest ?? result.path,
+				sourcePath: result.moveDest ? sourcePath : undefined,
+				oldText: result.before,
+				newText: result.after,
 				meta,
 			},
 		},
 		perFileResult: {
-			path: result.path,
+			path: result.moveDest ?? result.path,
 			diff: diff.diff,
 			firstChangedLine,
 			diagnostics,
 			op: result.op,
+			move: result.moveDest,
+			sourcePath: result.moveDest ? sourcePath : undefined,
+			oldText: result.before,
+			newText: result.after,
 		},
 	};
 }
@@ -181,10 +217,10 @@ export async function executeHashlineSingle(
 			if (escalate) {
 				throw new ToolError(noChangeLoopDiagnostic(sectionResult.path, count));
 			}
-			return renderSection(sectionResult, undefined).toolResult;
+			return renderSection(sectionResult, undefined, prepared.section.path).toolResult;
 		}
 		resetNoopEdit(options.session, sectionResult.canonicalPath);
-		return renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path)).toolResult;
+		return renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path), prepared.section.path).toolResult;
 	}
 
 	// Multi-section: prepare every section up front so we fail fast before
@@ -215,7 +251,7 @@ export async function executeHashlineSingle(
 				: new ToolError(noChangeDiagnostic(sectionResult.path));
 		}
 		resetNoopEdit(options.session, sectionResult.canonicalPath);
-		rendered.push(renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path)));
+		rendered.push(renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path), prepared[i].section.path));
 	}
 
 	return {

package/src/edit/hashline/filesystem.ts

@@ -16,8 +16,9 @@
  * (batch request, diagnostics) lives on the instance and isn't safe to
  * share across concurrent edit tools.
  */
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { Filesystem, NotFoundError, type WriteResult } from "@oh-my-pi/hashline";
+import { Filesystem, NotFoundError, type PreflightWriteOptions, type WriteResult } from "@oh-my-pi/hashline";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
@@ -25,7 +26,7 @@ import { routeWriteThroughBridge } from "../../tools/acp-bridge";
 import { assertEditableFileContent } from "../../tools/auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
 import { isInternalUrlPath } from "../../tools/path-utils";
-import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
+import { enforcePlanModeWrite, resolvePlanPath, targetsLocalSandbox } from "../../tools/plan-mode-guard";
 import { canonicalSnapshotKey } from "../file-snapshot-store";
 import { readEditFileText, serializeEditFileText } from "../read-file";
 import type { LspBatchRequest } from "../renderer";
@@ -92,12 +93,17 @@ export class HashlineFilesystem extends Filesystem {
 		// Internal-URL authored targets (`local://`, `vault://`, …) are approved
 		// at the lower "read" privilege; never let one redirect onto a "write".
 		if (isInternalUrlPath(authoredPath)) return false;
-		// Recovery only fixes a mistyped working-tree path: confine the resolved
-		// target to the working tree (realpath-normalized). A plain-path "write"
-		// approval must not redirect into the artifact sandbox, the secret vault,
-		// or any out-of-tree file the user never named.
+		// Recovery rebinds a bare/mis-typed authored path onto the file its
+		// snapshot tag uniquely names. Confine the redirect to locations a plain
+		// "write" may legitimately target:
+		//  1. the working tree (the model dropped the directory), or
+		//  2. the session `local://` sandbox where plan/scratch artifacts live —
+		//     the snapshot tag proves the model wrote/read that exact file this
+		//     session, so a bare `plan.md#tag` should land on `local://plan.md`.
+		// The secret vault and any other out-of-tree path stay refused.
 		const root = canonicalSnapshotKey(this.session.cwd);
-		return resolvedPath === root || resolvedPath.startsWith(`${root}${path.sep}`);
+		if (resolvedPath === root || resolvedPath.startsWith(`${root}${path.sep}`)) return true;
+		return targetsLocalSandbox(this.session, resolvedPath);
 	}
 
 	async readText(relativePath: string): Promise<string> {
@@ -117,10 +123,45 @@ export class HashlineFilesystem extends Filesystem {
 		return content;
 	}
 
-	async preflightWrite(relativePath: string): Promise<void> {
+	async preflightWrite(relativePath: string, options?: PreflightWriteOptions): Promise<void> {
+		const fileOp = options?.fileOp;
+		if (fileOp?.kind === "rem") {
+			enforcePlanModeWrite(this.session, relativePath, { op: "delete" });
+			return;
+		}
+		if (fileOp?.kind === "move") {
+			enforcePlanModeWrite(this.session, relativePath, { op: "update", move: fileOp.dest });
+			return;
+		}
 		enforcePlanModeWrite(this.session, relativePath, { op: "update" });
 	}
 
+	async delete(relativePath: string): Promise<void> {
+		enforcePlanModeWrite(this.session, relativePath, { op: "delete" });
+		const absolutePath = this.resolveAbsolute(relativePath);
+		try {
+			await fs.rm(absolutePath);
+		} catch (error) {
+			if (isEnoent(error)) throw new NotFoundError(relativePath, error);
+			throw error;
+		}
+		invalidateFsScanAfterWrite(absolutePath);
+	}
+
+	async move(fromRelative: string, toRelative: string, content?: string): Promise<void> {
+		enforcePlanModeWrite(this.session, fromRelative, { op: "update", move: toRelative });
+		const fromAbsolute = this.resolveAbsolute(fromRelative);
+		const toAbsolute = this.resolveAbsolute(toRelative);
+		if (content !== undefined) {
+			await Bun.write(toAbsolute, content);
+			await fs.rm(fromAbsolute);
+		} else {
+			await fs.rename(fromAbsolute, toAbsolute);
+		}
+		invalidateFsScanAfterWrite(fromAbsolute);
+		invalidateFsScanAfterWrite(toAbsolute);
+	}
+
 	async writeText(relativePath: string, content: string): Promise<WriteResult> {
 		await this.preflightWrite(relativePath);
 		const absolutePath = this.resolveAbsolute(relativePath);

package/src/edit/index.ts

@@ -154,6 +154,7 @@ async function executeApplyPatchPerFile(
 				diagnostics: details?.diagnostics,
 				op: details?.op,
 				move: details?.move,
+				sourcePath: details?.sourcePath,
 				meta: details?.meta,
 				oldText: details?.oldText,
 				newText: details?.newText,

package/src/edit/modes/patch.ts

@@ -1849,12 +1849,21 @@ export async function executePatchSingle(
 		diff: "",
 		firstChangedLine: undefined,
 	};
-	if (result.change.type === "update" && result.change.oldContent && result.change.newContent) {
+	if (
+		result.change.type === "update" &&
+		result.change.oldContent !== undefined &&
+		result.change.newContent !== undefined
+	) {
 		const normalizedOld = normalizeToLF(stripBom(result.change.oldContent).text);
 		const normalizedNew = normalizeToLF(stripBom(result.change.newContent).text);
 		diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew, undefined, {
 			path: result.change.newPath ?? result.change.path,
 		});
+	} else if (result.change.type === "create" && result.change.newContent !== undefined) {
+		// The result is authoritative for rendering, so emit the added-content
+		// diff here rather than relying on the call-phase streaming preview.
+		const normalizedNew = normalizeToLF(stripBom(result.change.newContent).text);
+		diffResult = generateUnifiedDiffString("", normalizedNew, undefined, { path: result.change.path });
 	}
 
 	let resultText: string;
@@ -1896,6 +1905,7 @@ export async function executePatchSingle(
 			diagnostics: mergedDiagnostics,
 			op,
 			move: effectiveRename,
+			sourcePath: result.change.newPath ? resolvedPath : undefined,
 			meta,
 			oldText,
 			newText,