xtrm-tools 0.7.0 → 0.7.2

package/.xtrm/extensions/auto-update/index.ts

@@ -0,0 +1,71 @@
+/**
+ * oh-pi Auto Update — check for new oh-pi version on session start
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24h
+const STAMP_FILE = join(homedir(), ".pi", "agent", ".update-check");
+
+function readStamp(): number {
+  try { return Number(readFileSync(STAMP_FILE, "utf8").trim()) || 0; } catch { return 0; }
+}
+
+function writeStamp() {
+  try { writeFileSync(STAMP_FILE, String(Date.now())); } catch {}
+}
+
+function getLatestVersion(): string | null {
+  try {
+    return execSync("npm view oh-pi version", { encoding: "utf8", timeout: 8000 }).trim();
+  } catch { return null; }
+}
+
+function getCurrentVersion(): string | null {
+  // Read from the installed package.json
+  try {
+    const pkgPath = join(__dirname, "..", "..", "package.json");
+    if (existsSync(pkgPath)) {
+      return JSON.parse(readFileSync(pkgPath, "utf8")).version;
+    }
+  } catch {}
+  // Fallback: npm list
+  try {
+    const out = JSON.parse(execSync("npm list -g oh-pi --json --depth=0", { encoding: "utf8", timeout: 8000 }));
+    return out.dependencies?.["oh-pi"]?.version ?? null;
+  } catch { return null; }
+}
+
+export function isNewer(latest: string, current: string): boolean {
+  const a = latest.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    // Non-blocking: run check in background
+    setTimeout(async () => {
+      try {
+        if (Date.now() - readStamp() < CHECK_INTERVAL) return;
+        writeStamp();
+
+        const current = getCurrentVersion();
+        const latest = getLatestVersion();
+        if (!current || !latest || !isNewer(latest, current)) return;
+
+        const msg = `oh-pi ${latest} available (current: ${current}). Run: npx oh-pi@latest`;
+        if (ctx.hasUI) {
+          ctx.ui.toast?.(msg) ?? console.log(`\n💡 ${msg}\n`);
+        }
+      } catch {}
+    }, 2000);
+  });
+}

package/.xtrm/extensions/auto-update/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@xtrm/pi-auto-update",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: auto-update",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT"
+}

package/.xtrm/extensions/beads/index.ts

@@ -0,0 +1,232 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, EventAdapter } from "@xtrm/pi-core";
+
+export default function (pi: ExtensionAPI) {
+	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
+
+	let cachedSessionId: string | null = null;
+	let memoryGateFired = false;
+
+	// Resolve a stable session ID across event types.
+	const getSessionId = (ctx: any): string => {
+		const fromManager = ctx?.sessionManager?.getSessionId?.();
+		const fromContext = ctx?.sessionId ?? ctx?.session_id;
+		const resolved = fromManager || fromContext || cachedSessionId || process.pid.toString();
+		if (resolved && !cachedSessionId) cachedSessionId = resolved;
+		return resolved;
+	};
+
+	const getSessionClaim = async (sessionId: string, cwd: string): Promise<string | null> => {
+		const result = await SubprocessRunner.run("bd", ["kv", "get", `claimed:${sessionId}`], { cwd });
+		if (result.code !== 0) return null;
+		const claim = result.stdout.trim();
+		return claim.length > 0 ? claim : null;
+	};
+
+	const clearClaimMarker = async (sessionId: string, cwd: string) => {
+		await SubprocessRunner.run("bd", ["kv", "clear", `claimed:${sessionId}`], { cwd });
+	};
+
+	const isIssueInProgress = async (issueId: string, cwd: string): Promise<boolean | null> => {
+		const result = await SubprocessRunner.run("bd", ["show", issueId, "--json"], { cwd });
+		if (result.code !== 0 || !result.stdout.trim()) return null;
+		try {
+			const parsed = JSON.parse(result.stdout);
+			const issue = Array.isArray(parsed) ? parsed[0] : parsed;
+			if (!issue?.status) return null;
+			return issue.status === "in_progress";
+		} catch {
+			return null;
+		}
+	};
+
+	const getActiveClaim = async (sessionId: string, cwd: string): Promise<string | null> => {
+		const claim = await getSessionClaim(sessionId, cwd);
+		if (!claim) return null;
+
+		const inProgress = await isIssueInProgress(claim, cwd);
+		if (inProgress === false) {
+			await clearClaimMarker(sessionId, cwd);
+			return null;
+		}
+
+		return claim;
+	};
+
+	const getClosedThisSession = async (sessionId: string, cwd: string): Promise<string | null> => {
+		const result = await SubprocessRunner.run("bd", ["kv", "get", `closed-this-session:${sessionId}`], { cwd });
+		if (result.code !== 0) return null;
+		const issue = result.stdout.trim();
+		return issue.length > 0 ? issue : null;
+	};
+
+	const clearSessionMarkers = async (sessionId: string, cwd: string) => {
+		await SubprocessRunner.run("bd", ["kv", "clear", `claimed:${sessionId}`], { cwd });
+		await SubprocessRunner.run("bd", ["kv", "clear", `closed-this-session:${sessionId}`], { cwd });
+	};
+
+	const hasTrackableWork = async (cwd: string): Promise<boolean> => {
+		const result = await SubprocessRunner.run("bd", ["list"], { cwd });
+		if (result.code === 0) {
+			const counts = EventAdapter.parseBdCounts(result.stdout);
+			if (counts) return (counts.open + counts.inProgress) > 0;
+		}
+		return false;
+	};
+
+	const stripQuoted = (command: string): string => command.replace(/'[^']*'|"[^"]*"/g, "");
+	const isSpecialistsSubprocessCommand = (commandUnquoted: string): boolean =>
+		/\bspecialists\s+(run|resume|result|feed|stop|status)\b/.test(commandUnquoted);
+
+	const getClosedIssueIdFromCommand = (commandUnquoted: string): string | null => {
+		const match = commandUnquoted.match(/\bbd\s+close\s+(\S+)/);
+		const issueId = match?.[1]?.trim();
+		if (!issueId || issueId.startsWith("-")) return null;
+		return issueId;
+	};
+
+	const hasIssueMemoryAck = async (issueId: string, cwd: string): Promise<boolean> => {
+		const result = await SubprocessRunner.run("bd", ["kv", "get", `memory-acked:${issueId}`], { cwd });
+		return result.code === 0 && result.stdout.trim().length > 0;
+	};
+
+	const closeMemoryBlockReason = (issueId: string): string =>
+		`MEMORY_GATE_BLOCK issue=${issueId} run="bd remember '<insight>' && bd kv set 'memory-acked:${issueId}' 'saved:<key>'" or="bd kv set 'memory-acked:${issueId}' 'nothing novel:<reason>'" then="bd close ${issueId} --reason='<reason>'"`;
+
+	pi.on("session_start", async (_event, ctx) => {
+		cachedSessionId = ctx?.sessionManager?.getSessionId?.() ?? ctx?.sessionId ?? ctx?.session_id ?? cachedSessionId;
+		return undefined;
+	});
+
+	pi.on("tool_call", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		if (!EventAdapter.isBeadsProject(cwd)) return undefined;
+		const sessionId = getSessionId(ctx);
+
+		if (EventAdapter.isMutatingFileTool(event)) {
+			const claim = await getActiveClaim(sessionId, cwd);
+			if (!claim) {
+				const hasWork = await hasTrackableWork(cwd);
+				if (hasWork) {
+					if (ctx.hasUI) {
+						ctx.ui.notify("Beads: Edit blocked. Claim an issue first.", "warning");
+					}
+					return {
+						block: true,
+						reason: `No active claim for session ${sessionId}.\n  bd update <id> --claim\n`,
+					};
+				}
+			}
+		}
+
+		if (isToolCallEventType("bash", event)) {
+			const command = event.input.command ?? "";
+			const commandUnquoted = stripQuoted(command);
+
+			if (isSpecialistsSubprocessCommand(commandUnquoted)) return undefined;
+
+			const closedIssueId = getClosedIssueIdFromCommand(commandUnquoted);
+			if (closedIssueId) {
+				const acked = await hasIssueMemoryAck(closedIssueId, cwd);
+				if (!acked) {
+					return {
+						block: true,
+						reason: closeMemoryBlockReason(closedIssueId),
+					};
+				}
+			}
+
+			if (/\bgit\s+commit\b/.test(commandUnquoted)) {
+				const claim = await getActiveClaim(sessionId, cwd);
+				if (claim) {
+					return {
+						block: true,
+						reason: `Active claim [${claim}] — close it first.\n  bd close ${claim}\n  (Pi workflow) publish/merge are external steps; do not rely on xtrm finish.\n`,
+					};
+				}
+			}
+		}
+
+		return undefined;
+	});
+
+	pi.on("tool_result", async (event, ctx) => {
+		if (!isBashToolResult(event)) return undefined;
+
+		const command = event.input.command || "";
+		const sessionId = getSessionId(ctx);
+		const cwd = getCwd(ctx);
+
+		// Auto-claim on bd update --claim regardless of exit code.
+		if (/\bbd\s+update\b/.test(command) && /--claim\b/.test(command)) {
+			const issueMatch = command.match(/\bbd\s+update\s+(\S+)/);
+			if (issueMatch) {
+				const issueId = issueMatch[1];
+				await SubprocessRunner.run("bd", ["kv", "set", `claimed:${sessionId}`, issueId], { cwd });
+				memoryGateFired = false;
+				const claimNotice = `\n\n✅ **Beads**: Session \`${sessionId}\` claimed issue \`${issueId}\`. File edits are now unblocked.`;
+				return { content: [...event.content, { type: "text", text: claimNotice }] };
+			}
+		}
+
+		if (/\bbd\s+close\b/.test(command) && !event.isError) {
+			const closeMatch = command.match(/\bbd\s+close\s+(\S+)/);
+			const closedIssueId = closeMatch?.[1] ?? null;
+
+			if (closedIssueId) {
+				await SubprocessRunner.run("bd", ["kv", "set", `closed-this-session:${sessionId}`, closedIssueId], { cwd });
+				memoryGateFired = false;
+			}
+
+			const memoryGateText = closedIssueId
+				? `\n\n**Beads Memory Gate**: close-time memory ack verified for \`${closedIssueId}\` (\`memory-acked:${closedIssueId}\`).`
+				: `\n\n**Beads**: Work completed. Consider if this session produced insights worth persisting via \`bd remember\`.`;
+			return { content: [...event.content, { type: "text", text: memoryGateText }] };
+		}
+
+		return undefined;
+	});
+
+	// Memory gate: clean up session markers and check ack at agent_end/session_shutdown.
+	// Memory gate prompt was already injected into bd close tool_result context (silent, agent-visible only).
+	// No UI notification — parity with Claude Stop hook {additionalContext} pattern.
+	const triggerMemoryGateIfNeeded = async (ctx: any) => {
+		const cwd = getCwd(ctx);
+		if (!EventAdapter.isBeadsProject(cwd)) return;
+		const sessionId = getSessionId(ctx);
+
+		const markerCheck = await SubprocessRunner.run("bd", ["kv", "get", `memory-gate-done:${sessionId}`], { cwd });
+		if (markerCheck.code === 0) {
+			await SubprocessRunner.run("bd", ["kv", "clear", `memory-gate-done:${sessionId}`], { cwd });
+			await clearSessionMarkers(sessionId, cwd);
+			memoryGateFired = false;
+			return;
+		}
+
+		if (memoryGateFired) return;
+
+		const closedIssueId = await getClosedThisSession(sessionId, cwd);
+		if (!closedIssueId) return;
+
+		const closeTimeAcked = await hasIssueMemoryAck(closedIssueId, cwd);
+		if (closeTimeAcked) {
+			await SubprocessRunner.run("bd", ["kv", "clear", `closed-this-session:${sessionId}`], { cwd });
+			memoryGateFired = false;
+			return;
+		}
+
+		memoryGateFired = true;
+		// No notify — memory gate was injected into bd close tool_result content (silent, agent-visible only).
+	};
+
+	pi.on("agent_end", async (_event, ctx) => {
+		await triggerMemoryGateIfNeeded(ctx);
+		return undefined;
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		await triggerMemoryGateIfNeeded(ctx);
+		return undefined;
+	});
+}

package/.xtrm/extensions/beads/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@xtrm/pi-beads",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: beads",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT",
+  "dependencies": {
+    "@xtrm/pi-core": "^1.0.0"
+  }
+}

package/.xtrm/extensions/compact-header/index.ts

@@ -0,0 +1,69 @@
+/**
+ * oh-pi Compact Header — table-style startup info with dynamic column widths
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { VERSION } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+
+    ctx.ui.setHeader((_tui, theme) => ({
+      render(width: number): string[] {
+        const d = (s: string) => theme.fg("dim", s);
+        const a = (s: string) => theme.fg("accent", s);
+
+        const cmds = pi.getCommands();
+        const prompts = cmds.filter(c => c.source === "prompt").map(c => `/${c.name}`).join("  ");
+        const skills = cmds.filter(c => c.source === "skill").map(c => c.name).join("  ");
+        const model = ctx.model ? `${ctx.model.id}` : "no model";
+        const thinking = pi.getThinkingLevel();
+        const provider = ctx.model?.provider ?? "";
+
+        const pad = (s: string, w: number) => s + " ".repeat(Math.max(0, w - visibleWidth(s)));
+        const t = (s: string) => truncateToWidth(s, width);
+        const sep = d(" │ ");
+
+        // Right two columns are fixed width
+        const rCol = [
+          [d("esc"), a("interrupt"),   d("S-tab"), a("thinking")],
+          [d("^C"),  a("clear/exit"),  d("^O"),    a("expand")],
+          [d("^P"),  a("model"),       d("^G"),    a("editor")],
+          [d("/"),   a("commands"),    d("^V"),    a("paste")],
+          [d("!"),   a("bash"),        d(""),      a("")],
+        ];
+        const k1w = 6, v1w = 13, k2w = 6, v2w = 9;
+        const rightW = k1w + v1w + 3 + k2w + v2w + 3; // 3 for each sep
+
+        // Left column gets remaining space
+        const leftW = Math.max(20, width - rightW);
+        const lk = 9; // label width
+
+        const lCol = [
+          [d("version"), a(`v${VERSION}  ${provider}`)],
+          [d("model"),   a(model)],
+          [d("think"),   a(thinking)],
+          [d(""),        d("")],
+          [d(""),        d("")],
+        ];
+
+        const lines: string[] = [""];
+        for (let i = 0; i < 5; i++) {
+          const [lk0, lv0] = lCol[i];
+          const [rk0, rv0, rk1, rv1] = rCol[i];
+          const left = truncateToWidth(pad(lk0, lk) + lv0, leftW);
+          const right = pad(rk0, k1w) + pad(rv0, v1w) + sep + pad(rk1, k2w) + rv1;
+          lines.push(t(pad(left, leftW) + sep + right));
+        }
+
+        if (prompts) lines.push(t(`${pad(d("prompts"), lk)}${a(prompts)}`));
+        if (skills) lines.push(t(`${pad(d("skills"), lk)}${a(skills)}`));
+        lines.push(d("─".repeat(width)));
+
+        return lines;
+      },
+      invalidate() {},
+    }));
+  });
+}

package/.xtrm/extensions/compact-header/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@xtrm/pi-compact-header",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: compact-header",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT"
+}

package/.xtrm/extensions/core/adapter.ts

@@ -0,0 +1,52 @@
+import * as fs from "node:fs";
+import * as nodePath from "node:path";
+
+import type { ExtensionAPI, ToolCallEvent } from "@mariozechner/pi-coding-agent";
+import { PI_MUTATING_FILE_TOOLS } from "./guard-rules";
+
+export class EventAdapter {
+	/**
+	 * Checks if the tool event is a mutating file operation (write, edit, etc).
+	 */
+	static isMutatingFileTool(event: ToolCallEvent<any, any>): boolean {
+		return PI_MUTATING_FILE_TOOLS.includes(event.toolName);
+	}
+
+	/**
+	 * Extracts the target path from a tool input, resolving against the current working directory.
+	 */
+	static extractPathFromToolInput(event: ToolCallEvent<any, any>, cwd: string): string | null {
+		const input = event.input;
+		if (!input) return null;
+
+		const pathRaw = input.path || input.file || input.filePath;
+		if (typeof pathRaw === "string") {
+			return pathRaw; // Usually Pi passes absolute paths anyway or paths relative to root
+		}
+
+		return null;
+	}
+
+	/**
+	 * Safely formats a block reason string to ensure UI readiness.
+	 */
+	static formatBlockReason(prefix: string, details: string): string {
+		return `${prefix}: ${details}`;
+	}
+	/**
+	 * Returns true if the given directory is a beads project (has a .beads directory).
+	 */
+	static isBeadsProject(cwd: string): boolean {
+		return fs.existsSync(nodePath.join(cwd, ".beads"));
+	}
+
+	/**
+	 * Parses the summary line from `bd list` output.
+	 * Returns { open, inProgress } or null if the line is absent.
+	 */
+	static parseBdCounts(output: string): { open: number; inProgress: number } | null {
+		const m = output.match(/Total:\s*\d+\s+issues?\s*\((\d+)\s+open,\s*(\d+)\s+in progress\)/);
+		if (!m) return null;
+		return { open: parseInt(m[1], 10), inProgress: parseInt(m[2], 10) };
+	}
+}

package/.xtrm/extensions/core/guard-rules.ts

@@ -0,0 +1,100 @@
+// Canonical guard-rule constants for Pi extensions.
+// Mirrors hooks/guard-rules.mjs with Pi-specific tool naming where needed.
+
+export const PI_MUTATING_FILE_TOOLS = [
+	"write",
+	"edit",
+	"replace_content",
+	"replace_lines",
+	"delete_lines",
+	"insert_at_line",
+	"create_text_file",
+	"rename_symbol",
+	"replace_symbol_body",
+	"insert_after_symbol",
+	"insert_before_symbol",
+];
+
+export const SAFE_BASH_PREFIXES = [
+	// Git read-only
+	"git status",
+	"git log",
+	"git diff",
+	"git show",
+	"git blame",
+	"git branch",
+	"git fetch",
+	"git remote",
+	"git config",
+	"git pull",
+	"git stash",
+	"git worktree",
+	"git checkout -b",
+	"git switch -c",
+	// Tools
+	"gh",
+	"bd",
+	"npx gitnexus",
+	"xtrm finish",
+	// Read-only filesystem
+	"cat",
+	"ls",
+	"head",
+	"tail",
+	"pwd",
+	"which",
+	"type",
+	"env",
+	"printenv",
+	"find",
+	"grep",
+	"rg",
+	"fd",
+	"wc",
+	"sort",
+	"uniq",
+	"cut",
+	"awk",
+	"jq",
+	"yq",
+	"bat",
+	"less",
+	"more",
+	"file",
+	"stat",
+	"du",
+	"tree",
+];
+
+export const DANGEROUS_BASH_PATTERNS = [
+	"sed\\s+-i",
+	"echo\\s+[^\\n]*>",
+	"printf\\s+[^\\n]*>",
+	"cat\\s+[^\\n]*>",
+	"tee\\b",
+	"(?:^|\\s)(?:vim|nano|vi)\\b",
+	"(?:^|\\s)mv\\b",
+	"(?:^|\\s)cp\\b",
+	"(?:^|\\s)rm\\b",
+	"(?:^|\\s)mkdir\\b",
+	"(?:^|\\s)touch\\b",
+	"(?:^|\\s)chmod\\b",
+	"(?:^|\\s)chown\\b",
+	">>",
+	"(?:^|\\s)git\\s+add\\b",
+	"(?:^|\\s)git\\s+commit\\b",
+	"(?:^|\\s)git\\s+merge\\b",
+	"(?:^|\\s)git\\s+push\\b",
+	"(?:^|\\s)git\\s+reset\\b",
+	"(?:^|\\s)git\\s+checkout\\b",
+	"(?:^|\\s)git\\s+rebase\\b",
+	"(?:^|\\s)git\\s+stash\\b",
+	"(?:^|\\s)npm\\s+install\\b",
+	"(?:^|\\s)bun\\s+install\\b",
+	"(?:^|\\s)bun\\s+add\\b",
+	"(?:^|\\s)node\\s+(?:-e|--eval)\\b",
+	"(?:^|\\s)bun\\s+(?:-e|--eval)\\b",
+	"(?:^|\\s)python\\s+-c\\b",
+	"(?:^|\\s)perl\\s+-e\\b",
+	"(?:^|\\s)ruby\\s+-e\\b",
+];

package/.xtrm/extensions/core/lib.ts

@@ -0,0 +1,3 @@
+export * from "./logger";
+export * from "./runner";
+export * from "./adapter";

package/.xtrm/extensions/core/logger.ts

@@ -0,0 +1,45 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LoggerOptions {
+	namespace: string;
+	level?: LogLevel;
+}
+
+export class Logger {
+	private namespace: string;
+	private level: LogLevel;
+
+	constructor(options: LoggerOptions) {
+		this.namespace = options.namespace;
+		this.level = options.level || "info";
+	}
+
+	private shouldLog(level: LogLevel): boolean {
+		const levels: LogLevel[] = ["debug", "info", "warn", "error"];
+		return levels.indexOf(level) >= levels.indexOf(this.level);
+	}
+
+	debug(message: string, ...args: any[]) {
+		if (this.shouldLog("debug")) {
+			console.debug(`[${this.namespace}] DEBUG: ${message}`, ...args);
+		}
+	}
+
+	info(message: string, ...args: any[]) {
+		if (this.shouldLog("info")) {
+			console.info(`[${this.namespace}] INFO: ${message}`, ...args);
+		}
+	}
+
+	warn(message: string, ...args: any[]) {
+		if (this.shouldLog("warn")) {
+			console.warn(`[${this.namespace}] WARN: ${message}`, ...args);
+		}
+	}
+
+	error(message: string, ...args: any[]) {
+		if (this.shouldLog("error")) {
+			console.error(`[${this.namespace}] ERROR: ${message}`, ...args);
+		}
+	}
+}

package/.xtrm/extensions/core/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@xtrm/pi-core",
+  "version": "1.0.0",
+  "description": "Shared utilities for xtrm Pi extensions",
+  "type": "module",
+  "exports": {
+    ".": "./lib.ts",
+    "./lib": "./lib.ts",
+    "./logger": "./logger.ts",
+    "./runner": "./runner.ts",
+    "./adapter": "./adapter.ts",
+    "./guard-rules": "./guard-rules.ts",
+    "./session-state": "./session-state.ts"
+  },
+  "keywords": ["pi", "extension", "xtrm"],
+  "author": "xtrm",
+  "license": "MIT"
+}