@siuver/omp-debug-mode 0.1.2 → 0.1.4

package/src/ui.ts

@@ -0,0 +1,103 @@
+import type { ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import { PROCEED_REMINDER } from "./methodology";
+import type { DebugState, EvidenceRequest } from "./state";
+import { pendingEvidenceRequests } from "./state";
+
+export const WIDGET_MAX_LINES = 10;
+const WIDGET_MAX_WIDTH = 90;
+
+export type WidgetTone = "accent" | "dim";
+
+export interface WidgetLine {
+	text: string;
+	tone: WidgetTone;
+}
+
+export function statusLabel(state: DebugState): string {
+	if (state.phase === "waiting") return "🐞 waiting-repro";
+	if (state.phase === "round") return `🐞 round ${state.round}`;
+	return "🐞 cleanup";
+}
+
+function clip(text: string): string {
+	return text.length > WIDGET_MAX_WIDTH ? `${text.slice(0, WIDGET_MAX_WIDTH - 1)}…` : text;
+}
+
+/** The command surface is the only interaction path at the gate. */
+const COMMAND_LINES = [
+	"/debug-proceed [details]",
+	"/debug-evidence <request-id> <path>",
+	"/debug-done · /debug-abort · /debug-status",
+] as const;
+
+function plural(count: number, singular: string): string {
+	return `${count} ${singular}${count === 1 ? "" : "s"}`;
+}
+
+function logEntries(count: number): string {
+	return count === 1 ? "1 log entry" : `${count} log entries`;
+}
+
+/**
+ * Reproduction-gate widget: the call to action, pending user evidence,
+ * reproduction-step context, the command surface, and the live evidence
+ * counter. Commands are the only interaction path — there is no menu. The
+ * live log counter is always the final line within the host's line budget.
+ */
+export function waitingWidgetLines(
+	state: DebugState,
+	logCount: number,
+	pendingEvidence: EvidenceRequest[] = pendingEvidenceRequests(state, state.round),
+): WidgetLine[] {
+	const lines: WidgetLine[] = [{ text: PROCEED_REMINDER, tone: "accent" }];
+	for (const request of pendingEvidence.slice(0, 2)) {
+		lines.push({ text: clip(`↪ ${request.id} ${request.title}: ${request.instructions[0] ?? ""}`), tone: "accent" });
+	}
+	for (const command of COMMAND_LINES) lines.push({ text: command, tone: "accent" });
+
+	// Reproduction details are useful context, but command discoverability and
+	// the live log counter must survive the host's ten-line widget limit.
+	const reserved = lines.length + 2;
+	const stepBudget = Math.max(0, WIDGET_MAX_LINES - reserved);
+	if (stepBudget > 0 && state.reproductionSteps.length > 0) {
+		const showMoreLine = state.reproductionSteps.length > stepBudget;
+		const shownCount = showMoreLine ? Math.max(0, stepBudget - 1) : stepBudget;
+		for (const step of state.reproductionSteps.slice(0, shownCount)) {
+			lines.push({ text: clip(step), tone: "dim" });
+		}
+		const hidden = state.reproductionSteps.length - shownCount;
+		if (hidden > 0) lines.push({ text: `… +${plural(hidden, "more step")} in the transcript`, tone: "dim" });
+	}
+	lines.push({
+		text: `evidence: ${plural(pendingEvidence.length, "pending request")}, ${plural(state.evidenceArtifacts.length, "attached artifact")}`,
+		tone: pendingEvidence.length > 0 || state.evidenceArtifacts.length > 0 ? "accent" : "dim",
+	});
+	lines.push({
+		text: `run ${state.runId ?? "none"} — ${logEntries(logCount)}`,
+		tone: logCount > 0 ? "accent" : "dim",
+	});
+	return lines.slice(0, WIDGET_MAX_LINES);
+}
+
+/**
+ * Render the status entry and the reproduction widget. `getLogCount` is only
+ * consulted at the reproduction gate so idle phases do not touch the log files.
+ */
+export function applyUi(ctx: ExtensionContext | null, state: DebugState, getLogCount: () => number): void {
+	if (!ctx?.hasUI) return;
+	if (!state.active) {
+		ctx.ui.setStatus("debug-mode", undefined);
+		ctx.ui.setWidget("debug-mode", undefined);
+		return;
+	}
+	ctx.ui.setStatus("debug-mode", ctx.ui.theme.fg("warning", statusLabel(state)));
+	if (state.phase !== "waiting") {
+		ctx.ui.setWidget("debug-mode", undefined);
+		return;
+	}
+	const lines = waitingWidgetLines(state, getLogCount());
+	ctx.ui.setWidget(
+		"debug-mode",
+		lines.map(line => ctx.ui.theme.fg(line.tone, line.text)),
+	);
+}

package/src/workspace.ts

@@ -0,0 +1,79 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export const DEBUG_ROOT = path.join(".omp", "debug");
+/** Line written to `.git/info/exclude` so probe logs stay out of `git status`. */
+export const EXCLUDE_LINE = ".omp/debug/";
+
+/**
+ * Directory name for one session's probe logs. Two omp sessions debugging the
+ * same repository must not share `current.jsonl`: each round truncates it and
+ * teardown deletes it, so a shared directory would let one session erase the
+ * other's evidence.
+ */
+export function sessionDirName(sessionId: string | null | undefined): string {
+	const safe = (sessionId ?? "").replace(/[^A-Za-z0-9_-]/g, "");
+	return safe.length > 0 ? safe.slice(0, 16) : "session";
+}
+
+export function debugDirFor(cwd: string, sessionId: string | null | undefined): string {
+	return path.resolve(cwd, DEBUG_ROOT, sessionDirName(sessionId));
+}
+
+/** Walk up from `cwd` to the enclosing `.git` directory, if there is a plain one. */
+export function findGitDir(cwd: string): string | null {
+	let dir = path.resolve(cwd);
+	for (;;) {
+		const candidate = path.join(dir, ".git");
+		try {
+			// A `.git` file means a worktree or submodule; leave those alone.
+			if (fs.statSync(candidate).isDirectory()) return candidate;
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+export function needsExcludeLine(contents: string): boolean {
+	return !contents.split(/\r?\n/).some(line => line.trim() === EXCLUDE_LINE);
+}
+
+export function appendExcludeLine(contents: string): string {
+	if (!needsExcludeLine(contents)) return contents;
+	const separator = contents.length === 0 || contents.endsWith("\n") ? "" : "\n";
+	return `${contents}${separator}${EXCLUDE_LINE}\n`;
+}
+
+/**
+ * Keep probe logs out of the user's working diff via the repository-local
+ * exclude file, which is never committed. Best effort: a read-only or absent
+ * git directory is not a reason to fail debugging.
+ */
+export function excludeDebugLogsFromGit(cwd: string): boolean {
+	const gitDir = findGitDir(cwd);
+	if (!gitDir) return false;
+	const excludeFile = path.join(gitDir, "info", "exclude");
+	try {
+		let contents = "";
+		try {
+			contents = fs.readFileSync(excludeFile, "utf8");
+		} catch {}
+		if (!needsExcludeLine(contents)) return false;
+		fs.mkdirSync(path.dirname(excludeFile), { recursive: true });
+		fs.writeFileSync(excludeFile, appendExcludeLine(contents));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/** Remove the shared `.omp/debug` parent once the last session directory is gone. */
+export function pruneDebugRoot(cwd: string): void {
+	try {
+		fs.rmdirSync(path.resolve(cwd, DEBUG_ROOT));
+	} catch {}
+	try {
+		fs.rmdirSync(path.resolve(cwd, ".omp"));
+	} catch {}
+}

package/src/review-actions.ts

@@ -1,11 +0,0 @@
-export const REVIEW_MARK_FIXED = "Mark as fixed";
-export const REVIEW_PROCEED = "Proceed with captured logs";
-export const REVIEW_ADD_DETAILS = "Add reproduction details";
-export const REVIEW_ABORT = "Abort debug mode";
-
-export const REVIEW_OPTIONS = [
-	REVIEW_MARK_FIXED,
-	REVIEW_PROCEED,
-	REVIEW_ADD_DETAILS,
-	REVIEW_ABORT,
-] as const;