one-code-extension 0.4.1 → 0.5.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,78 @@
+/** Comparisons for the historical context stack. No pi imports or live-state reads. */
+import { createHash } from "node:crypto";
+import { buildClaudeMdBlock, buildContextBlock, type ContextFile } from "./claude-context.ts";
+import type { ReminderEntry } from "./reminders.ts";
+
+export const CONTEXT_FACT_KEYS = ["claude-context", "one-code-context", "claude-context-context", "claude-context-date"] as const;
+export const RESUME_FACTS_KEY = "context-resume-changes";
+export const DATE_CHANGE_KEY = "claude-context-date-change";
+
+export interface ContextFactsBaseline {
+	instructions: string;
+	memory: string;
+	git: string;
+	/** A compaction starts a new snapshot epoch, not a new conversation. */
+	atCompaction: boolean;
+	/**
+	 * The directory the facts were read in: the session's cwd, or the entered
+	 * worktree at a compaction. A resume compares in the same one. Absent in
+	 * older snapshots.
+	 */
+	cwd?: string;
+}
+
+const fingerprint = (value: unknown): string => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+
+/** Hash only what the model was shown, not unshown file tails or filesystem mtimes. */
+export function contextFactsBaseline(input: {
+	contextFiles: ContextFile[];
+	memoryIndex: { path: string; content: string } | null;
+	gitStatus: string | null;
+	atCompaction: boolean;
+	cwd?: string;
+}): ContextFactsBaseline {
+	return {
+		instructions: fingerprint(buildClaudeMdBlock({ contextFiles: input.contextFiles })),
+		memory: fingerprint(buildClaudeMdBlock({ contextFiles: [], memoryIndex: input.memoryIndex })),
+		git: fingerprint(input.gitStatus),
+		atCompaction: input.atCompaction,
+		...(input.cwd !== undefined ? { cwd: input.cwd } : {}),
+	};
+}
+
+export function storedFactsBaseline(value: unknown): ContextFactsBaseline | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const v = value as Record<string, unknown>;
+	if (![v.instructions, v.memory, v.git].every((part) => typeof part === "string" && /^[a-f0-9]{64}$/.test(part)) || typeof v.atCompaction !== "boolean") return undefined;
+	const { cwd, ...facts } = v;
+	return { ...facts, ...(typeof cwd === "string" ? { cwd } : {}) } as unknown as ContextFactsBaseline;
+}
+
+/** 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; the historical blocks themselves remain byte-identical. */
+export function resumeFactsNotice(before: ContextFactsBaseline, current: ContextFactsBaseline): string | undefined {
+	const changed: string[] = [];
+	if (before.git !== current.git) changed.push("git status changed");
+	if (before.memory !== current.memory) changed.push("the memory index changed");
+	if (before.instructions !== current.instructions) changed.push("CLAUDE.md-family instructions changed");
+	if (changed.length === 0) return undefined;
+	return `Since the saved context snapshot, ${changed.join("; ")}. The earlier context block reflects ${before.atCompaction ? "the latest compaction" : "the session's start"}, not the current workspace. Read the current files or run git status if needed.`;
+}
+
+/** Old snapshots lack separate fingerprints: do not invent which half of # claudeMd changed. */
+export function legacyResumeFactsNotice(stack: readonly ReminderEntry[], live: {
+	instructions: string | null;
+	email: string | null;
+	gitStatus: string | null;
+}): string | undefined {
+	const changed: string[] = [];
+	const previousContext = stack.find((entry) => entry.key === "claude-context-context")?.text ?? null;
+	const gitPart = (text: string | null) => text?.match(/# gitStatus\n[\s\S]*?(?=\n\nOne Code attached this context automatically;|$)/)?.[0] ?? null;
+	if (gitPart(previousContext) !== gitPart(buildContextBlock(live))) changed.push("git status changed");
+	if ((stack.find((entry) => entry.key === "claude-context")?.text ?? null) !== live.instructions) changed.push("CLAUDE.md-family instructions or the memory index changed");
+	return changed.length ? `Since the saved context snapshot, ${changed.join("; ")}. The earlier context block reflects the session's start, not the current workspace. Read the current files or run git status if needed.` : undefined;
+}

package/extensions/lib/context-stack.ts

@@ -0,0 +1,81 @@
+/** Session-file context snapshots and the bus contract. No stored value grants permissions. */
+import type { ReminderEntry } from "./reminders.ts";
+
+export const CONTEXT_STACK_ENTRY = "one-code:context-stack";
+export const CONTEXT_STATE_ENTRY = "one-code:context-state";
+export const CONTEXT_RESTORE_CHANNEL = "one-code:context-restore";
+export const CONTEXT_BASELINE_CHANNEL = "one-code:context-baseline";
+/** A completed compaction replaces the Claude context facts, including absent blocks. */
+export const CONTEXT_FACTS_REFRESH_CHANNEL = "one-code:context-facts-refresh";
+
+export interface ContextStackSnapshot {
+	version: 1;
+	stack: ReminderEntry[];
+	sticky: ReminderEntry[];
+	/** Delivered one-shots/breadcrumbs; absent in older snapshots. */
+	pinned?: ReminderEntry[];
+	/** Emitter-owned announcement baselines, not live configuration. */
+	baselines: Record<string, unknown>;
+}
+export interface ContextRestoreRequest { restored?: ContextStackSnapshot }
+export interface ContextBaseline { key: string; value: unknown }
+export interface ContextFactsRefresh { entries: ReminderEntry[]; baseline: unknown }
+interface Bus { emit(channel: string, data: unknown): void }
+
+/** Synchronous request/reply: system-reminder restores before the emitters' session_start hooks. */
+export function restoredContext(events: Bus): ContextStackSnapshot | undefined {
+	const request: ContextRestoreRequest = {};
+	events.emit(CONTEXT_RESTORE_CHANNEL, request);
+	return request.restored;
+}
+
+/** Phase-1 capabilities must be re-emitted by their live owners, including removal. */
+export const LIVE_CONTEXT_KEYS = new Set(["environment", "model-line", "one-shot", "skills"]);
+
+/** Session facts and phase-2 emitters keep even an absent original block absent. */
+export const RESTORED_STACK_KEYS = new Set([
+	"claude-context", "one-code-context", "claude-context-context", "claude-context-date",
+	"total-tokens-first", "auto-mode-note", "deferred-tools", "mcp-instructions", "mcp-failures",
+	"subagent-models", "subagent-agents", "subagent-delegation",
+]);
+
+function record(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function anchor(value: unknown): boolean {
+	return record(value) && ((value.kind === "user" && typeof value.timestamp === "number" && Number.isFinite(value.timestamp)) ||
+		(value.kind === "toolResult" && typeof value.toolCallId === "string"));
+}
+function entries(value: unknown, placement: "first-prepend" | "sticky-append" | "pinned"): value is ReminderEntry[] {
+	return Array.isArray(value) && value.every((e) => record(e) &&
+		(placement === "pinned" ? e.placement === "last-append" || e.placement === "user-prepend" : e.placement === placement) && typeof e.text === "string" &&
+		typeof e.order === "number" && Number.isFinite(e.order) &&
+		(e.key === undefined || typeof e.key === "string") && (e.suffix === undefined || typeof e.suffix === "string") &&
+		(e.toolCallId === undefined || placement === "sticky-append" && typeof e.toolCallId === "string") &&
+		["raw", "systemRoleOnly", "skipStackCarrier"].every((key) => e[key] === undefined || typeof e[key] === "boolean") &&
+		(e.since === undefined || typeof e.since === "number" && Number.isFinite(e.since)) &&
+		(e.until === undefined || placement === "sticky-append" && typeof e.until === "number" && Number.isFinite(e.until)) &&
+		(e.userPins === undefined || placement === "sticky-append" && Array.isArray(e.userPins) && e.userPins.every((stamp) => typeof stamp === "number" && Number.isFinite(stamp))) &&
+		(e.opener === undefined || e.opener === null || typeof e.opener === "number" && Number.isFinite(e.opener)) &&
+		(e.tailPin === undefined || anchor(e.tailPin)) && (placement === "pinned" ? anchor(e.pin) : e.pin === undefined));
+}
+
+/** Read only the selected branch. Malformed/unknown versions are ignored, never partly restored. */
+export function contextStackOnBranch(branch: readonly { type: string; customType?: string; data?: unknown }[]): ContextStackSnapshot | undefined {
+	let snapshot: ContextStackSnapshot | undefined;
+	for (const entry of branch) {
+		if (entry.type !== "custom" || !record(entry.data) || entry.data.version !== 1) continue;
+		const data = entry.data;
+		if (data.pinned !== undefined && !entries(data.pinned, "pinned")) continue;
+		if (entry.customType === CONTEXT_STACK_ENTRY && entries(data.stack, "first-prepend") && entries(data.sticky, "sticky-append") && record(data.baselines)) {
+			snapshot = structuredClone(data) as unknown as ContextStackSnapshot;
+		} else if (snapshot && entry.customType === CONTEXT_STATE_ENTRY && entries(data.sticky, "sticky-append") && record(data.baselines) &&
+			(data.stack === undefined || entries(data.stack, "first-prepend"))) {
+			if (data.stack !== undefined) snapshot.stack = structuredClone(data.stack) as ReminderEntry[];
+			snapshot.sticky = structuredClone(data.sticky);
+			if (data.pinned !== undefined) snapshot.pinned = structuredClone(data.pinned) as ReminderEntry[];
+			snapshot.baselines = structuredClone(data.baselines);
+		}
+	}
+	return snapshot;
+}