@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/src/config/live-snapshot.ts

@@ -0,0 +1,187 @@
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+
+import { detectConfigFile, parseJsoncRecovering } from "../shared/jsonc-parser";
+import { mmcProjectConfigBasePath, opencodeUserConfigBasePath } from "./config-paths";
+
+export interface ConfigSnapshot<T> {
+    readonly generation: number;
+    readonly digest: string;
+    readonly adoptedAt: number;
+    readonly effective: T;
+}
+
+export interface ConfigReloadFailure {
+    readonly path: string;
+    readonly message: string;
+    readonly digest: string;
+}
+
+interface FileState {
+    metadata: string;
+    digest: string;
+}
+
+/**
+ * Publishes a project configuration only after the user and project files parse
+ * and the loader assembles the final effective configuration successfully.
+ */
+export class LiveConfigReader<T> {
+    private snapshot: ConfigSnapshot<T>;
+    private files = new Map<string, FileState>();
+    private initialized = false;
+    private warned = new Set<string>();
+    private failure: ConfigReloadFailure | undefined;
+
+    constructor(
+        private readonly directory: string,
+        initial: T,
+        private readonly load: () => T,
+        // Callers pass the host's log sink; the default is silent so a caller that
+        // forgets never writes into the host process's stderr.
+        private readonly onLog: (message: string) => void = () => {},
+        private readonly changedKeys: (previous: T, next: T) => readonly string[] = (
+            previous,
+            next,
+        ) =>
+            Object.keys(next as object).filter(
+                (key) =>
+                    JSON.stringify((previous as Record<string, unknown>)[key]) !==
+                    JSON.stringify((next as Record<string, unknown>)[key]),
+            ),
+    ) {
+        this.snapshot = {
+            generation: 1,
+            digest: "initial",
+            adoptedAt: Date.now(),
+            effective: initial,
+        };
+    }
+
+    current(): ConfigSnapshot<T> {
+        return this.snapshot;
+    }
+
+    lastFailure(): ConfigReloadFailure | undefined {
+        return this.failure;
+    }
+
+    poll(): ConfigSnapshot<T> {
+        const paths = [opencodeUserConfigBasePath(), mmcProjectConfigBasePath(this.directory)].map(
+            (base) => detectConfigFile(base).path,
+        );
+        const next = new Map<string, FileState>();
+        let changed = paths.some((path) => !this.files.has(path));
+        for (const path of paths) {
+            let metadata: string;
+            try {
+                const stat = statSync(path);
+                metadata = `${stat.mtimeMs}:${stat.size}:${stat.ino}`;
+            } catch (error) {
+                if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+                    this.reportFailure(path, String(error), error);
+                    return this.snapshot;
+                }
+                metadata = "absent";
+            }
+            const previous = this.files.get(path);
+            if (previous?.metadata === metadata) {
+                next.set(path, previous);
+                continue;
+            }
+            let content: string;
+            try {
+                content = metadata === "absent" ? "" : readFileSync(path, "utf8");
+            } catch (error) {
+                this.reportFailure(path, String(error), error);
+                return this.snapshot;
+            }
+            const digest = createHash("sha256").update(content).digest("hex");
+            if (metadata !== "absent") {
+                const parsed = parseJsoncRecovering(content);
+                if (
+                    parsed.issues.length ||
+                    !parsed.value ||
+                    typeof parsed.value !== "object" ||
+                    Array.isArray(parsed.value)
+                ) {
+                    const issue = parsed.issues[0];
+                    this.reportFailure(
+                        path,
+                        digest,
+                        issue
+                            ? `${issue.line}:${issue.column}: ${issue.message}`
+                            : "expected an object",
+                    );
+                    return this.snapshot;
+                }
+            }
+            next.set(path, { metadata, digest });
+            changed ||= previous?.digest !== digest;
+        }
+        if (!changed) {
+            this.files = next;
+            return this.snapshot;
+        }
+        let effective: T;
+        try {
+            effective = this.load();
+        } catch (error) {
+            this.reportFailure(paths[0] ?? this.directory, "load", error);
+            return this.snapshot;
+        }
+        // The loader reads both tiers again. A concurrent writer must not let it
+        // publish a mixed user/project pair under the metadata staged above.
+        for (const path of paths) {
+            let metadata = "absent";
+            try {
+                const stat = statSync(path);
+                metadata = `${stat.mtimeMs}:${stat.size}:${stat.ino}`;
+            } catch (error) {
+                if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+                    this.reportFailure(path, String(error), error);
+                    return this.snapshot;
+                }
+            }
+            if (metadata !== next.get(path)?.metadata) return this.snapshot;
+        }
+        const digest = createHash("sha256")
+            .update(paths.map((path) => `${path}:${next.get(path)?.digest}`).join("\n"))
+            .digest("hex");
+        this.files = next;
+        this.failure = undefined;
+        if (!this.initialized) {
+            this.initialized = true;
+            this.snapshot = {
+                generation: 1,
+                digest,
+                adoptedAt: this.snapshot.adoptedAt,
+                effective,
+            };
+        } else if (this.snapshot.digest !== digest) {
+            const keys = this.changedKeys(this.snapshot.effective, effective);
+            this.snapshot = {
+                generation: this.snapshot.generation + 1,
+                digest,
+                adoptedAt: Date.now(),
+                effective,
+            };
+            // A file can change (a save, a comment edit) without any setting changing;
+            // only a real change is worth a line.
+            if (keys.length > 0) {
+                this.onLog(
+                    `config reloaded gen=${this.snapshot.generation} keys=[${keys.join(",")}]`,
+                );
+            }
+        }
+        return this.snapshot;
+    }
+
+    private reportFailure(path: string, digest: string, error: unknown): void {
+        const message = error instanceof Error ? error.message : String(error);
+        this.failure = { path, message, digest };
+        if (this.warned.has(`${path}:${digest}`)) return;
+        this.warned.add(`${path}:${digest}`);
+        this.onLog(`config reload failed ${path}: ${message}`);
+    }
+}

package/src/config/migrate-experimental.ts

@@ -0,0 +1,92 @@
+/**
+ * Startup-time shim for graduated experimental features (shared OpenCode + Pi).
+ *
+ * Features have graduated out of the `experimental.*` namespace across releases:
+ *  - this release: `experimental.temporal_awareness` / `caveman_text_compression`
+ *    → top-level keys; and `experimental.auto_search` → `memory.auto_search`.
+ *
+ * Doctor runs an on-disk migration, but users who never run doctor would
+ * otherwise lose their opt-in/opt-out because the graduated keys are no longer
+ * in the schema — Zod silently strips unknown keys. This shim runs in-memory on
+ * every load: if the user has legacy `experimental.<graduated-key>` blocks, it
+ * reshapes the raw config so the new schema sees them at their graduated path.
+ * The on-disk file stays untouched (doctor is the tool that cleans it up), and
+ * the user's explicit intent is preserved for this session's runtime behavior.
+ *
+ * Primitive values (e.g., `experimental.user_memories: true`) are coerced to
+ * `{ enabled: <bool> }` object form so Zod accepts them. Without this coercion,
+ * the primitive would fail schema validation and fall back to the graduated
+ * default — silently flipping a user's explicit `false` to the new `true`
+ * default, or vice versa.
+ *
+ * Idempotent: if the destination path already has a value, the destination wins
+ * (the user has started graduating), merging sub-fields so nothing is lost.
+ */
+export function migrateLegacyExperimental(
+    rawConfig: Record<string, unknown>,
+    warnings: string[],
+): Record<string, unknown> {
+    const experimental = rawConfig.experimental;
+    if (typeof experimental !== "object" || experimental === null) {
+        return rawConfig;
+    }
+    const exp = experimental as Record<string, unknown>;
+    // Graduated out of the (now retired) `experimental.*` namespace.
+    //  - temporal_awareness / caveman_text_compression → top-level config keys.
+    //  - auto_search → under `memory.*` (recall features).
+    const TOP_LEVEL_GRADUATED = ["temporal_awareness", "caveman_text_compression"] as const;
+    const MEMORY_GRADUATED = ["auto_search"] as const;
+    const hasGraduated =
+        TOP_LEVEL_GRADUATED.some((k) => k in exp) || MEMORY_GRADUATED.some((k) => k in exp);
+    if (!hasGraduated) {
+        return rawConfig;
+    }
+
+    // Clone shallowly — we only mutate the experimental + memory branches.
+    const patched: Record<string, unknown> = { ...rawConfig };
+    const memory =
+        typeof patched.memory === "object" && patched.memory !== null
+            ? { ...(patched.memory as Record<string, unknown>) }
+            : ({} as Record<string, unknown>);
+    const newExperimental = { ...exp };
+
+    // Relocate a graduated flag from experimental.* to its new home. The
+    // destination value wins when both exist (the user already graduated); for
+    // object-shaped flags we merge sub-fields so partial destination settings
+    // (e.g. only score_threshold) don't drop the old enabled state. A primitive
+    // destination value (e.g. temporal_awareness, or a shorthand like
+    // `auto_search: true`) wins as-is.
+    const relocate = (key: string, dest: Record<string, unknown>, destLabel: string): void => {
+        if (!(key in exp)) return;
+        const oldValue = exp[key];
+        const existing = dest[key];
+        if (existing === undefined) {
+            dest[key] = oldValue;
+            warnings.push(
+                `Migrated "experimental.${key}" → "${destLabel}${key}" in-memory (run \`doctor\` to persist).`,
+            );
+        } else if (
+            typeof oldValue === "object" &&
+            oldValue !== null &&
+            typeof existing === "object" &&
+            existing !== null
+        ) {
+            dest[key] = {
+                ...(oldValue as Record<string, unknown>),
+                ...(existing as Record<string, unknown>),
+            };
+        }
+        delete newExperimental[key];
+    };
+    for (const key of TOP_LEVEL_GRADUATED) relocate(key, patched, "");
+    for (const key of MEMORY_GRADUATED) relocate(key, memory, "memory.");
+
+    patched.experimental = newExperimental;
+    // Only attach `memory` if the relocation actually populated it (or it already
+    // existed) so we don't synthesize an empty memory block for configs that only
+    // migrated top-level keys.
+    if (Object.keys(memory).length > 0) {
+        patched.memory = memory;
+    }
+    return patched;
+}

package/src/config/misplaced-agent-model.test.ts

@@ -0,0 +1,55 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, it } from "bun:test";
+import { resolveHistorianModel } from "../shared/model-resolution";
+import { misplacedAgentModelWarnings, parsePluginConfig } from "./index";
+
+/**
+ * A bare `historian.model` is schema-valid, reads naturally, and resolves to
+ * nothing. These tests pin both halves: that the resolver really does ignore it,
+ * and that the loader now says so instead of leaving the user with a subsystem
+ * that looks configured and never runs.
+ */
+describe("misplaced agent model warning", () => {
+    it("is what a top-level historian.model actually resolves to", () => {
+        // The premise, asserted rather than assumed: if this ever starts
+        // resolving, the warning below becomes wrong and should be deleted.
+        expect(resolveHistorianModel({ historian: { model: "openai/gpt-5" } }, "opencode")).toEqual(
+            {
+                primary: undefined,
+                fallbacks: [],
+            },
+        );
+    });
+
+    it("warns when the model sits outside every harness block", () => {
+        const warnings = misplacedAgentModelWarnings({ historian: { model: "openai/gpt-5" } });
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0]).toContain("historian.model is not read");
+        expect(warnings[0]).toContain("historian.opencode.model");
+    });
+
+    it("stays quiet when a harness block carries the model", () => {
+        expect(
+            misplacedAgentModelWarnings({
+                historian: { model: "openai/gpt-5", opencode: { model: "openai/gpt-5" } },
+            }),
+        ).toEqual([]);
+        expect(
+            misplacedAgentModelWarnings({ historian: { opencode: { model: "openai/gpt-5" } } }),
+        ).toEqual([]);
+        expect(misplacedAgentModelWarnings({})).toEqual([]);
+        expect(misplacedAgentModelWarnings({ historian: { disable: true } })).toEqual([]);
+    });
+
+    it("reaches the pinned config-warning channel", () => {
+        // configWarnings is what /mmc-status and the Pi session-start notice
+        // read, so landing here is what makes the warning visible.
+        const parsed = parsePluginConfig({ historian: { model: "openai/gpt-5" } });
+        expect(
+            (parsed.configWarnings ?? []).some((warning) =>
+                warning.includes("historian.model is not read"),
+            ),
+        ).toBe(true);
+    });
+});

package/src/config/profiles.ts

@@ -0,0 +1,106 @@
+import { ConfigProfilesSchema } from "./schema/magic-context";
+
+export interface ProfileResolution {
+    /** User config minus the profile declarations and selector. */
+    userBase: Record<string, unknown>;
+    /** Project config minus the profile declarations and selector. */
+    projectBase: Record<string, unknown>;
+    /** The validated user-owned overlay for the active profile, if any. */
+    overlay: Record<string, unknown>;
+    /** The selected profile name, absent when no valid profile is active. */
+    activeProfile?: string;
+    warnings: string[];
+}
+
+interface ProfileSelection {
+    declared: boolean;
+    name?: string;
+}
+
+function withoutProfileFields(raw: Record<string, unknown>): Record<string, unknown> {
+    const copy = { ...raw };
+    delete copy.profile;
+    delete copy.profiles;
+    return copy;
+}
+
+function readProfileSelection(raw: Record<string, unknown>): ProfileSelection {
+    if (!Object.hasOwn(raw, "profile")) return { declared: false };
+    const value = raw.profile;
+    if (typeof value !== "string") return { declared: true };
+    const name = value.trim();
+    return name.length > 0 ? { declared: true, name } : { declared: true };
+}
+
+/**
+ * Resolve the user-owned profile overlay without retaining any process-global
+ * selection state. Callers merge `userBase`, `overlay`, then `projectBase` for
+ * every project load, so a Pi /cd or OpenCode multi-root session cannot borrow
+ * another repository's selected profile.
+ */
+export function resolveConfigProfile(args: {
+    userRaw: Record<string, unknown>;
+    projectRaw: Record<string, unknown>;
+}): ProfileResolution {
+    const warnings: string[] = [];
+    const userSelection = readProfileSelection(args.userRaw);
+    const projectSelection = readProfileSelection(args.projectRaw);
+    const selection = projectSelection.name
+        ? { name: projectSelection.name, source: "project" }
+        : userSelection.name
+          ? { name: userSelection.name, source: "user" }
+          : undefined;
+
+    if (projectSelection.declared && !projectSelection.name) {
+        warnings.push(
+            "Ignoring invalid profile selection from project config; expected a non-empty string.",
+        );
+    }
+    if (!projectSelection.declared && userSelection.declared && !userSelection.name) {
+        warnings.push(
+            "Ignoring invalid profile selection from user config; expected a non-empty string.",
+        );
+    }
+
+    let profiles: Record<string, Record<string, unknown>> = {};
+    if (Object.hasOwn(args.userRaw, "profiles")) {
+        const parsed = ConfigProfilesSchema.safeParse(args.userRaw.profiles);
+        if (parsed.success) {
+            profiles = parsed.data as Record<string, Record<string, unknown>>;
+        } else {
+            warnings.push(
+                "Ignoring profiles from user config: invalid profile configuration; profiles may contain only historian harness model blocks.",
+            );
+        }
+    }
+
+    if (!selection) {
+        return {
+            userBase: withoutProfileFields(args.userRaw),
+            projectBase: withoutProfileFields(args.projectRaw),
+            overlay: {},
+            warnings,
+        };
+    }
+
+    if (!Object.hasOwn(profiles, selection.name)) {
+        warnings.push(
+            `Unknown profile "${selection.name}" selected by ${selection.source} config; using base config without a profile.`,
+        );
+        return {
+            userBase: withoutProfileFields(args.userRaw),
+            projectBase: withoutProfileFields(args.projectRaw),
+            overlay: {},
+            warnings,
+        };
+    }
+
+    const overlay = profiles[selection.name];
+    return {
+        userBase: withoutProfileFields(args.userRaw),
+        projectBase: withoutProfileFields(args.projectRaw),
+        overlay,
+        activeProfile: selection.name,
+        warnings,
+    };
+}

package/src/config/project-config-trust-boundary.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createTestTempDirFromPath } from "../shared/test-temp-dir";
+import { loadPluginConfigDetailed } from "./index";
+
+/**
+ * A repository's project config may only tighten what the user configured. A
+ * wrong-typed or otherwise invalid project value used to replace the user's
+ * value in the raw deep merge; schema recovery then dropped the key and used
+ * the schema DEFAULT, so a cloned repo could reset user-only settings (turn
+ * compaction back on, unset the historian model, force a re-embed) or lower
+ * compaction thresholds. These cases pin that an invalid project value is
+ * ignored and the user's value survives.
+ */
+function loadUserAndProject(user: unknown, project: unknown) {
+    const xdg = createTestTempDirFromPath(join(tmpdir(), "mc-trust-user-"));
+    const projectDir = createTestTempDirFromPath(join(tmpdir(), "mc-trust-proj-"));
+    mkdirSync(join(xdg, "opencode"), { recursive: true });
+    mkdirSync(join(projectDir, ".mmc"), { recursive: true });
+    writeFileSync(join(xdg, "opencode", "mmc.jsonc"), JSON.stringify(user), "utf-8");
+    writeFileSync(join(projectDir, ".mmc", "mmc.jsonc"), JSON.stringify(project), "utf-8");
+    const origXdg = process.env.XDG_CONFIG_HOME;
+    process.env.XDG_CONFIG_HOME = xdg;
+    try {
+        return loadPluginConfigDetailed(projectDir, false);
+    } finally {
+        if (origXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+        else process.env.XDG_CONFIG_HOME = origXdg;
+        rmSync(xdg, { recursive: true, force: true });
+        rmSync(projectDir, { recursive: true, force: true });
+    }
+}
+
+describe("project config cannot reset user settings with a wrong-typed parent block", () => {
+    it("keeps the user's compaction block when the project sets compaction:false", () => {
+        const loaded = loadUserAndProject(
+            { compaction: { enabled: false } },
+            { compaction: false },
+        );
+        expect(loaded.config.compaction).toMatchObject({ enabled: false });
+        expect(loaded.config.configWarnings?.join("\n")).toContain("compaction");
+    });
+
+    it("keeps the user's historian model when the project sets historian:1", () => {
+        const loaded = loadUserAndProject(
+            { historian: { opencode: { model: "anthropic/claude-x" } } },
+            { historian: 1 },
+        );
+        expect(loaded.config.historian?.opencode?.model).toBe("anthropic/claude-x");
+    });
+
+    it("keeps storage.enforce_private_permissions:false when the project sets storage:0", () => {
+        const loaded = loadUserAndProject(
+            { storage: { enforce_private_permissions: false } },
+            { storage: 0 },
+        );
+        expect(loaded.config.storage?.enforce_private_permissions).toBe(false);
+    });
+
+    it("keeps the user's prompt_surface override when the project sets prompt_surface:1", () => {
+        const loaded = loadUserAndProject(
+            { prompt_surface: { default: "light" } },
+            { prompt_surface: 1 },
+        );
+        expect(loaded.config.prompt_surface).toMatchObject({ default: "light" });
+    });
+
+    it("keeps the user's nested leaf when the project gives that leaf a wrong type", () => {
+        const loaded = loadUserAndProject(
+            { memory: { auto_search: { enabled: false } } },
+            { memory: { auto_search: { enabled: "nope" } } },
+        );
+        expect(loaded.config.memory?.auto_search?.enabled).toBe(false);
+    });
+
+    it("still applies a valid project value next to an invalid one", () => {
+        const loaded = loadUserAndProject(
+            { compaction: { enabled: false }, cache_ttl: "5m" },
+            { compaction: false, cache_ttl: "1h" },
+        );
+        expect(loaded.config.compaction).toMatchObject({ enabled: false });
+        expect(loaded.config.cache_ttl).toBe("1h");
+    });
+
+    it("reports the ignored project value as schema recovery", () => {
+        const loaded = loadUserAndProject(
+            { compaction: { enabled: false } },
+            { compaction: false },
+        );
+        expect(loaded.recoveredTopLevelKeys).toContain("compaction");
+        expect(loaded.loadOutcome).toBe("schema-recovery");
+    });
+});
+
+describe("project config cannot lower compaction thresholds", () => {
+    it("does not lower a user threshold of 88 to a project value of 81", () => {
+        const loaded = loadUserAndProject(
+            { execute_threshold_percentage: 88 },
+            { execute_threshold_percentage: 81 },
+        );
+        expect(loaded.config.execute_threshold_percentage).toBe(88);
+    });
+
+    it("does not lower a per-model user threshold of 89 to a project value of 82", () => {
+        const loaded = loadUserAndProject(
+            { execute_threshold_percentage: { default: 70, "a/b": 89 } },
+            { execute_threshold_percentage: { "a/b": 82 } },
+        );
+        expect(loaded.config.execute_threshold_percentage).toEqual({ default: 70, "a/b": 89 });
+    });
+
+    it("still raises the threshold to a valid project value above 80", () => {
+        const loaded = loadUserAndProject(
+            { execute_threshold_percentage: 70 },
+            { execute_threshold_percentage: 85 },
+        );
+        expect(loaded.config.execute_threshold_percentage).toBe(85);
+    });
+
+    it("keeps the user threshold of 80 when the project value 10 is invalid", () => {
+        const loaded = loadUserAndProject(
+            { execute_threshold_percentage: 80 },
+            { execute_threshold_percentage: 10 },
+        );
+        expect(loaded.config.execute_threshold_percentage).toBe(80);
+    });
+
+    it("keeps the user threshold when the project value is a string or an invalid object", () => {
+        for (const projectValue of ["x", { default: 5 }]) {
+            const loaded = loadUserAndProject(
+                { execute_threshold_percentage: 80 },
+                { execute_threshold_percentage: projectValue },
+            );
+            expect(loaded.config.execute_threshold_percentage).toBe(80);
+        }
+    });
+
+    it("keeps the user's execute_threshold_tokens when the project sets a scalar", () => {
+        const loaded = loadUserAndProject(
+            { execute_threshold_tokens: { default: 300_000 } },
+            { execute_threshold_tokens: 5 },
+        );
+        expect(loaded.config.execute_threshold_tokens).toEqual({ default: 300_000 });
+    });
+
+    it("keeps the user's execute_threshold_tokens.default when the project value is out of range", () => {
+        const loaded = loadUserAndProject(
+            { execute_threshold_tokens: { default: 300_000 } },
+            { execute_threshold_tokens: { default: 10 } },
+        );
+        expect(loaded.config.execute_threshold_tokens).toEqual({ default: 300_000 });
+    });
+});
+
+describe("project command block", () => {
+    it("adds well-formed new commands but never replaces user or built-in ones", () => {
+        const loaded = loadUserAndProject(
+            { command: { "my-cmd": { template: "user template" } } },
+            {
+                command: {
+                    "my-cmd": { template: "repository template" },
+                    "mmc-status": { template: "repository status" },
+                    "repo-cmd": { template: "repository command", description: "from the repo" },
+                    "bad-cmd": { template: 5 },
+                    "no-template": { description: "missing template" },
+                },
+            },
+        );
+        expect(loaded.config.command).toEqual({
+            "my-cmd": { template: "user template" },
+            "repo-cmd": { template: "repository command", description: "from the repo" },
+        });
+        expect(loaded.config.configWarnings?.join("\n")).toContain("command.my-cmd");
+    });
+
+    it("ignores a project command block that is not an object", () => {
+        const loaded = loadUserAndProject(
+            { command: { "my-cmd": { template: "user template" } } },
+            { command: "nope" },
+        );
+        expect(loaded.config.command).toEqual({ "my-cmd": { template: "user template" } });
+    });
+});