one-code-extension 0.4.1 → 0.6.0

package/extensions/lib/config-mode.ts

@@ -0,0 +1,112 @@
+/**
+ * Where One Code reads its configuration and context: the two modes
+ * (working-docs/features/config-modes/).
+ *
+ * - `claude-compatible` (the default): Claude Code's `~/.claude`,
+ *   `<repo>/.claude`, `CLAUDE.md` and `~/.claude.json`, plus the cross-tool
+ *   `AGENTS.md` and `.agents/skills` and pi's own directories.
+ * - `independent`: no Claude Code path at all; `~/.onecode`, `ONECODE.md`,
+ *   `<repo>/.onecode/`, pi's directories and the cross-tool files, with
+ *   auto-memory under `~/.onecode/projects/<slug>/memory/`.
+ *
+ * The choice is `configMode` in One Code's user settings
+ * (`~/.onecode/settings.json`), never read from `~/.claude`;
+ * `ONECODE_CONFIG_MODE` overrides it. Readers run at factory time and on
+ * `resources_discover`, before any session event, so the mode is read from
+ * disk, not broadcast.
+ *
+ * The mode is fixed for the life of the process: the first read pins it in a
+ * `globalThis` slot that every extension's module instance shares (jiti gives
+ * each its own copy of this file). The system prompt names the memory folder
+ * and must stay byte-stable, so a `/memory` toggle saves the setting and
+ * applies from the next start.
+ */
+
+import os from "node:os";
+import { join } from "node:path";
+import { readJsonFile } from "./atomic-write.ts";
+import { claudeUserDir, oneCodeStateDir } from "./paths.ts";
+
+export type ConfigMode = "claude-compatible" | "independent";
+
+const DEFAULT_CONFIG_MODE: ConfigMode = "claude-compatible";
+
+/** How each mode is named to the user (`/memory`, `/doctor`). */
+export const MODE_LABELS: Record<ConfigMode, string> = {
+	"claude-compatible": "Claude-compatible",
+	independent: "Independent",
+};
+
+/** The key in `~/.onecode/settings.json`. */
+export const CONFIG_MODE_KEY = "configMode";
+const CONFIG_MODE_ENV = "ONECODE_CONFIG_MODE";
+
+function isConfigMode(value: unknown): value is ConfigMode {
+	return value === "claude-compatible" || value === "independent";
+}
+
+/**
+ * The saved mode: `ONECODE_CONFIG_MODE`, else `configMode` in One Code's user
+ * settings, else the default. A missing, malformed or unknown value reads as
+ * the default (fail toward today's behaviour); an unknown env value is ignored.
+ */
+export function readConfigMode(home: string = os.homedir(), env: Record<string, string | undefined> = process.env): ConfigMode {
+	return configModeFromEnv(env) ?? savedConfigMode(home, env);
+}
+
+/** The mode `ONECODE_CONFIG_MODE` sets, or undefined when it is unset or unknown. */
+export function configModeFromEnv(env: Record<string, string | undefined> = process.env): ConfigMode | undefined {
+	const value = env[CONFIG_MODE_ENV];
+	return isConfigMode(value) ? value : undefined;
+}
+
+/**
+ * `configMode` in `~/.onecode/settings.json` alone, ignoring the env override.
+ * The path is spelled out: importing `oneCodeSettingsPath` would cycle through
+ * `one-code-settings.ts` and `memory.ts`.
+ */
+export function savedConfigMode(home: string = os.homedir(), env: Record<string, string | undefined> = process.env): ConfigMode {
+	const value = readJsonFile<Record<string, unknown>>(join(oneCodeStateDir(env, home), "settings.json"))?.[CONFIG_MODE_KEY];
+	return isConfigMode(value) ? value : DEFAULT_CONFIG_MODE;
+}
+
+const MODE_SLOT = Symbol.for("one-code:config-mode");
+
+/**
+ * The mode this process runs in: read once, then pinned for every extension.
+ * Tests that need a different mode call `resetConfigModeForTest` first.
+ */
+export function configMode(): ConfigMode {
+	const slot = globalThis as { [MODE_SLOT]?: ConfigMode };
+	return (slot[MODE_SLOT] ??= readConfigMode());
+}
+
+export function resetConfigModeForTest(mode?: ConfigMode): void {
+	const slot = globalThis as { [MODE_SLOT]?: ConfigMode };
+	if (mode) slot[MODE_SLOT] = mode;
+	else delete slot[MODE_SLOT];
+}
+
+/** Whether Claude Code's own locations are read: `~/.claude`, `.claude/`, `CLAUDE.md`, `~/.claude.json`. */
+export function claudeSourcesOn(): boolean {
+	return configMode() === "claude-compatible";
+}
+
+/**
+ * The user-level folder that holds agents, commands, workflows and the user
+ * settings file: `~/.claude` (`CLAUDE_CONFIG_DIR`) in Claude-compatible mode,
+ * `~/.onecode` (`ONECODE_STATE_DIR`) in independent mode.
+ */
+export function userConfigDir(home: string, env: Record<string, string | undefined> = process.env): string {
+	return claudeSourcesOn() ? claudeUserDir(home, env) : oneCodeStateDir(env, home);
+}
+
+/** The project-level folder's name: `.claude`, or `.onecode` in independent mode. */
+export function projectConfigDirName(): string {
+	return claudeSourcesOn() ? ".claude" : ".onecode";
+}
+
+/** The project-level counterpart of `userConfigDir`: `<cwd>/.claude` or `<cwd>/.onecode`. */
+export function projectConfigDir(cwd: string): string {
+	return join(cwd, projectConfigDirName());
+}

package/extensions/lib/consent-dialogs.ts

@@ -0,0 +1,63 @@
+/** Serialize startup consent modals over the event bus (jiti modules cannot share a queue). */
+const CHANNEL = "one-code:consent-dialog";
+interface Events {
+	emit(channel: string, data: unknown): void;
+	on(channel: string, listener: (data: unknown) => void): unknown;
+}
+interface Request {
+	show: (signal?: AbortSignal) => Promise<unknown>;
+	/** External includes are the last startup consent, after hooks and MCP. */
+	afterStartup?: boolean;
+	result?: Promise<unknown>;
+}
+
+/** The early claude-context extension owns the queue and resets it with its session. */
+export function installConsentDialogs(events: Events): () => void {
+	let controller = new AbortController();
+	let tail: Promise<unknown> = Promise.resolve();
+	let startupReady = false;
+	let waiting: Array<() => void> = [];
+	events.on(CHANNEL, (data) => {
+		if ((data as { ready?: boolean }).ready) {
+			startupReady = true;
+			const pending = waiting;
+			waiting = [];
+			for (const enqueue of pending) enqueue();
+			return;
+		}
+		const request = data as Request;
+		const signal = controller.signal;
+		let enqueue!: () => void;
+		request.result = new Promise((resolve, reject) => {
+			const abort = () => resolve(undefined);
+			signal.addEventListener("abort", abort, { once: true });
+			enqueue = () => {
+				const previous = tail;
+				tail = request.result!.catch(() => {});
+				previous.then(() => signal.aborted ? undefined : request.show(signal)).then(resolve, reject)
+					.finally(() => signal.removeEventListener("abort", abort));
+			};
+		});
+		if (request.afterStartup && !startupReady) waiting.push(enqueue);
+		else enqueue();
+	});
+	return () => {
+		controller.abort();
+		controller = new AbortController();
+		tail = Promise.resolve();
+		startupReady = false;
+		waiting = [];
+	};
+}
+
+/** MCP finishes registering startup prompts; the first turn is the fallback when MCP is not loaded. */
+export function startupConsentReady(events: Pick<Events, "emit">): void {
+	events.emit(CHANNEL, { ready: true });
+}
+
+/** Without the owner (an extension loaded alone), retain the normal direct-dialog behavior. */
+export function consentDialog<T>(events: Pick<Events, "emit">, show: (signal?: AbortSignal) => Promise<T>, afterStartup = false): Promise<T | undefined> {
+	const request: Request = { show, afterStartup };
+	events.emit(CHANNEL, request);
+	return (request.result ?? show()) as Promise<T | undefined>;
+}

package/extensions/lib/consent-preview.ts

@@ -10,13 +10,17 @@
  * truth the user should read before approving anything this large).
  */
 
+import { escapeControlText } from "./terminal-text.ts";
+
 const PER_ITEM_CAP = 2000;
 const TOTAL_CAP = 4000;
 
 export function boundConsentItems(items: string[], moreHint: string): string {
 	const shown: string[] = [];
 	let used = 0;
-	for (const item of items) {
+	// Control characters are shown as visible escapes: an SGR conceal or a
+	// cursor move in a command could otherwise hide the part the user approves.
+	for (const item of items.map(escapeControlText)) {
 		const capped = item.length > PER_ITEM_CAP ? `${item.slice(0, PER_ITEM_CAP)}… [truncated, ${item.length} chars]` : item;
 		// Always show the first item (so an empty modal never happens); stop once
 		// the budget is spent.

package/extensions/lib/consent-stores.ts

@@ -0,0 +1,48 @@
+/**
+ * Where One Code keeps the user's consent to a repository's own
+ * configuration (pure).
+ *
+ * Each store records that the user approved something a checkout ships, keyed
+ * by a hash the model can compute: its hooks, its `.mcp.json` servers, its
+ * allow rules and workspace directories, and the language servers that run
+ * its build. An entry is standing permission, so a write to a store is a
+ * gate-control write: the auto-mode safety floor stops it
+ * (`auto-mode/safety-floor.ts`), and a classifier that was talked around
+ * never gets to approve it. One home for the paths, so a new store cannot be
+ * left off the floor.
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { oneCodeStateDir } from "./paths.ts";
+
+/** Each consent store, relative to One Code's state dir. */
+const CONSENT_STORES = {
+	hooks: ["hooks", "project-approvals.json"],
+	mcp: ["mcp", "project-approvals.json"],
+	projectAllow: ["permissions", "project-allow-approvals.json"],
+	lsp: ["lsp", "trusted-projects.json"],
+} as const;
+
+export type ConsentStore = keyof typeof CONSENT_STORES;
+
+/** One consent store's file, under `ONECODE_STATE_DIR` when it is set. */
+export function consentStorePath(store: ConsentStore, env: Record<string, string | undefined> = process.env, home: string = homedir()): string {
+	return join(oneCodeStateDir(env, home), ...CONSENT_STORES[store]);
+}
+
+/** Every consent store's file, for the safety floor. */
+export function consentStorePaths(home: string, env: Record<string, string | undefined> = process.env): string[] {
+	return (Object.keys(CONSENT_STORES) as ConsentStore[]).map((store) => consentStorePath(store, env, home));
+}
+
+/**
+ * A consent store under any literal `.onecode` directory, as a forward-slashed
+ * path tail: the textual floor's counterpart of `consentStorePaths`, for a
+ * store in another home or spelled through a symlink the resolver missed.
+ */
+export const CONSENT_STORE_TAIL = new RegExp(
+	`/\\.onecode/(${Object.values(CONSENT_STORES)
+		.map((parts) => parts.join("/").replace(/[.]/g, "\\."))
+		.join("|")})$`,
+);

package/extensions/lib/context-facts.ts

@@ -0,0 +1,97 @@
+/**
+ * What claude-context's message-1 blocks tell, as ledger facts, and the notice
+ * for a resumed session whose workspace changed since (pure). The blocks are
+ * live state; an epoch records their fingerprints with its request, so the
+ * first request of a resumed process compares them with the live files and git
+ * status, and says what changed once. The historical blocks stay as sent.
+ */
+import { buildClaudeMdBlock, type ContextFile } from "./claude-context.ts";
+import type { ToldFact } from "./ledger/records.ts";
+import { contentHash } from "./ledger/wire.ts";
+import { toldBlockFact } from "./reminders.ts";
+
+/** The told keys of the fingerprints (whole-text block facts) and of the compaction flag (a mode). */
+export const FACT_KEYS = {
+	instructions: "context-facts:instructions",
+	memory: "context-facts:memory",
+	git: "context-facts:git",
+	date: "context-facts:date",
+	/** On when the epoch's blocks were taken at a compaction, not at the session's start. */
+	compaction: "context-facts:compaction",
+} as const;
+
+/** A told block's hash (`toldBlockFact`): for a string or null it is the sha256 of its JSON. */
+const fingerprint = contentHash;
+
+/** Fingerprints of only what the model was shown, not unshown file tails or filesystem mtimes. */
+export interface ContextFingerprints {
+	instructions: string;
+	memory: string;
+}
+
+export function contextFingerprints(input: { contextFiles: ContextFile[]; memoryIndex: { path: string; content: string } | null }): ContextFingerprints {
+	return {
+		instructions: fingerprint(buildClaudeMdBlock({ contextFiles: input.contextFiles })),
+		memory: fingerprint(buildClaudeMdBlock({ contextFiles: [], memoryIndex: input.memoryIndex })),
+	};
+}
+
+export const gitFingerprint = (gitStatus: string | null): string => fingerprint(gitStatus);
+
+/** The live workspace's fingerprints for the resumed-session check: the instructions, the memory index and, when a git snapshot is taken, the git status. */
+export type LiveFingerprints = ContextFingerprints & { git?: string };
+
+export function liveFingerprints(files: Parameters<typeof contextFingerprints>[0], gitStatus: string | null, withGit: boolean): LiveFingerprints {
+	return { ...contextFingerprints(files), ...(withGit ? { git: gitFingerprint(gitStatus) } : {}) };
+}
+export const dateFingerprint = (date: string): string => fingerprint(date);
+
+/** The facts the instructions block tells. */
+export function instructionFacts(prints: ContextFingerprints): ToldFact[] {
+	return [
+		{ kind: "block", key: FACT_KEYS.instructions, hash: prints.instructions },
+		{ kind: "block", key: FACT_KEYS.memory, hash: prints.memory },
+	];
+}
+
+/** The facts the context block tells: its git snapshot, and whether a compaction took it. */
+export function contextBlockFacts(gitStatus: string | null, atCompaction: boolean): ToldFact[] {
+	return [
+		toldBlockFact(FACT_KEYS.git, gitStatus),
+		{ kind: "mode", key: FACT_KEYS.compaction, on: atCompaction },
+	];
+}
+
+/** A refreshed git snapshot must not describe itself as the conversation's initial status. */
+export function compactionGitStatus(text: string | null): string | null {
+	return text?.replace("This is the git status at the start of the conversation.", "This is the git status at the latest compaction.") ?? null;
+}
+
+/**
+ * One short factual notice when the live workspace differs from what the
+ * epoch's blocks told, and the facts that bring the told state up to date.
+ * Undefined when nothing the epoch told has changed, or the epoch told none
+ * of it (its blocks predate the facts).
+ */
+export function resumeFactsNotice(
+	told: ReadonlyMap<string, string>,
+	atCompaction: boolean,
+	live: ContextFingerprints & { git?: string },
+): { text: string; facts: ToldFact[] } | undefined {
+	const changed: string[] = [];
+	const facts: ToldFact[] = [];
+	const compare = (key: string, hash: string | undefined, what: string) => {
+		const before = told.get(key);
+		if (hash === undefined || before === undefined || before === hash) return;
+		changed.push(what);
+		facts.push({ kind: "block", key, hash });
+	};
+	compare(FACT_KEYS.git, live.git, "git status changed");
+	compare(FACT_KEYS.memory, live.memory, "the memory index changed");
+	compare(FACT_KEYS.instructions, live.instructions, "CLAUDE.md-family instructions changed");
+	if (changed.length === 0) return undefined;
+	return {
+		text: `Since the saved context snapshot, ${changed.join("; ")}. The earlier context block reflects ${atCompaction ? "the latest compaction" : "the session's start"}, not the current workspace. Read the current files or run git status if needed.`,
+		facts,
+	};
+}

package/extensions/lib/covered-messages.ts

@@ -0,0 +1,23 @@
+/**
+ * The whole conversation each request covers, as pi built it, for compaction's
+ * summarizer. (btw's and recap's standalone fallbacks read the current branch
+ * at call time instead: lib/side-call.ts `branchMessages`.) Inside an epoch
+ * the ledger (extensions/ledger) cuts a request to its tail before every later
+ * `context` hook, so the full list comes with the request's plan instead.
+ */
+
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { LEDGER_PLAN_CHANNEL, type RequestPlan } from "./ledger/plan.ts";
+
+/** Call `onRequest` at each request's `context` pass with every message the request covers. */
+export function followCoveredMessages(pi: ExtensionAPI, onRequest: (messages: AgentMessage[], ctx: ExtensionContext) => void): void {
+	let planned: readonly AgentMessage[] | undefined;
+	pi.events.on(LEDGER_PLAN_CHANNEL, (data) => {
+		planned = (data as RequestPlan).messages as readonly AgentMessage[];
+	});
+	pi.on("context", (event, ctx) => {
+		onRequest([...(planned ?? event.messages)], ctx);
+		planned = undefined;
+	});
+}