@diffexai/diffex 0.2.1 → 0.2.3

package/THIRD-PARTY-NOTICES.txt

@@ -1,5 +1,9 @@
-Diffex modifications copyright 2026 Luntraa, Inc.
-Pi-derived portions retain the complete MIT terms in LICENSE.
+Diffex
+Copyright 2026 Luntraa, Inc.
+
+Where this distribution contains Pi Agent Harness-derived portions,
+those portions retain their MIT terms and copyright notice in LICENSE.
+The Apache-2.0 package declaration does not replace third-party terms.
 
 ===== highlight.js@11.9.0 (BSD-3-Clause) =====
 BSD 3-Clause License

package/dist/AGENTS.md

@@ -0,0 +1,28 @@
+# Development Rules
+
+## Conversational Style
+
+- Keep responses concise and direct, adapting detail and terminology to the user.
+- No emojis in commits, issues, PR comments, or code.
+- No fluff or cheerful filler text (e.g., "Thanks @user" not "Thanks so much @user!").
+- When the user asks a question, answer it first before making edits or running implementation commands.
+- Address the user's feedback directly before describing changes.
+
+## Code Quality
+
+- Follow repository instructions, conventions, and existing tooling.
+- Before editing or drawing conclusions, read enough surrounding code to understand the relevant behavior and dependencies.
+- Read affected files in full for broad changes; do not rely on search snippets alone for investigations or audits.
+- Ask before removing intentional functionality or code when the removal falls outside the requested scope or its purpose is unclear.
+- Preserve unrelated local changes and keep modifications focused on the requested task.
+
+## Commands
+
+- After changes, run relevant tests and checks, including any tests you create or modify.
+- Resolve failures caused by your changes and report any remaining failures or checks you could not run.
+- Write substantial or multiline ad-hoc scripts to a temporary file, run and revise them as needed, and remove your temporary files when done.
+- Simple one-line scripts may run directly in the shell.
+
+## User Override
+
+- Explicit user instructions take precedence over these defaults.

package/dist/cli/session-selection.d.ts

@@ -0,0 +1,7 @@
+import { SessionManager } from "../core/session-manager.ts";
+import type { SettingsManager } from "../core/settings-manager.ts";
+import type { Args } from "./args.ts";
+export declare function validateForkFlags(parsed: Args): void;
+export declare function validateSessionIdFlags(parsed: Args): void;
+export declare function createSessionManager(parsed: Args, cwd: string, sessionDir: string | undefined, settingsManager: SettingsManager): Promise<SessionManager>;
+export declare function applySessionName(parsed: Args, sessionManager: SessionManager): void;

package/dist/cli/session-selection.js

@@ -0,0 +1,181 @@
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import { assertValidSessionId, SessionManager } from "../core/session-manager.js";
+import { stopThemeWatcher } from "../modes/interactive/theme/theme.js";
+import { resolvePath } from "../utils/paths.js";
+import { selectSession } from "./session-picker.js";
+/**
+ * Resolve a session argument to a file path.
+ * If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
+ */
+async function findLocalSessionByExactId(sessionId, cwd, sessionDir) {
+    const localSessions = await SessionManager.list(cwd, sessionDir);
+    const localMatch = localSessions.find((s) => s.id === sessionId);
+    return localMatch ? { type: "local", path: localMatch.path } : undefined;
+}
+async function resolveSessionPath(sessionArg, cwd, sessionDir) {
+    // If it looks like a file path, resolve it before handing it to the session manager.
+    if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
+        return { type: "path", path: resolvePath(sessionArg, cwd) };
+    }
+    // Try to match as session ID in current project first
+    const localSessions = await SessionManager.list(cwd, sessionDir);
+    const localMatch = localSessions.find((s) => s.id === sessionArg) ?? localSessions.find((s) => s.id.startsWith(sessionArg));
+    if (localMatch) {
+        return { type: "local", path: localMatch.path };
+    }
+    // Try global search across all projects
+    const allSessions = await SessionManager.listAll(sessionDir);
+    const globalMatch = allSessions.find((s) => s.id === sessionArg) ?? allSessions.find((s) => s.id.startsWith(sessionArg));
+    if (globalMatch) {
+        return { type: "global", path: globalMatch.path, cwd: globalMatch.cwd };
+    }
+    // Not found anywhere
+    return { type: "not_found", arg: sessionArg };
+}
+/** Prompt user for yes/no confirmation */
+async function promptConfirm(message) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(`${message} [y/N] `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+    });
+}
+export function validateForkFlags(parsed) {
+    if (!parsed.fork)
+        return;
+    const conflictingFlags = [
+        parsed.session ? "--session" : undefined,
+        parsed.continue ? "--continue" : undefined,
+        parsed.resume ? "--resume" : undefined,
+        parsed.noSession ? "--no-session" : undefined,
+    ].filter((flag) => flag !== undefined);
+    if (conflictingFlags.length > 0) {
+        console.error(chalk.red(`Error: --fork cannot be combined with ${conflictingFlags.join(", ")}`));
+        process.exit(1);
+    }
+}
+export function validateSessionIdFlags(parsed) {
+    if (parsed.sessionId === undefined)
+        return;
+    const conflictingFlags = [
+        parsed.session ? "--session" : undefined,
+        parsed.continue ? "--continue" : undefined,
+        parsed.resume ? "--resume" : undefined,
+    ].filter((flag) => flag !== undefined);
+    if (conflictingFlags.length > 0) {
+        console.error(chalk.red(`Error: --session-id cannot be combined with ${conflictingFlags.join(", ")}`));
+        process.exit(1);
+    }
+    try {
+        assertValidSessionId(parsed.sessionId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+function openSessionOrExit(path, sessionDir) {
+    try {
+        return SessionManager.open(path, sessionDir);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+function forkSessionOrExit(sourcePath, cwd, sessionDir, sessionId) {
+    try {
+        return SessionManager.forkFrom(sourcePath, cwd, sessionDir, { id: sessionId });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+export async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
+    if (parsed.noSession || parsed.help || parsed.listModels !== undefined) {
+        return SessionManager.inMemory(cwd, parsed.sessionId !== undefined ? { id: parsed.sessionId } : undefined);
+    }
+    if (parsed.fork) {
+        if (parsed.sessionId) {
+            const existingTarget = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
+            if (existingTarget) {
+                console.error(chalk.red(`Session already exists with id '${parsed.sessionId}'`));
+                process.exit(1);
+            }
+        }
+        const resolved = await resolveSessionPath(parsed.fork, cwd, sessionDir);
+        switch (resolved.type) {
+            case "path":
+            case "local":
+            case "global":
+                return forkSessionOrExit(resolved.path, cwd, sessionDir, parsed.sessionId);
+            case "not_found":
+                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
+                process.exit(1);
+        }
+    }
+    if (parsed.session) {
+        const resolved = await resolveSessionPath(parsed.session, cwd, sessionDir);
+        switch (resolved.type) {
+            case "path":
+            case "local":
+                return openSessionOrExit(resolved.path, sessionDir);
+            case "global": {
+                console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
+                const shouldFork = await promptConfirm("Fork this session into current directory?");
+                if (!shouldFork) {
+                    console.log(chalk.dim("Aborted."));
+                    process.exit(0);
+                }
+                return forkSessionOrExit(resolved.path, cwd, sessionDir);
+            }
+            case "not_found":
+                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
+                process.exit(1);
+        }
+    }
+    if (parsed.resume) {
+        try {
+            const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, sessionDir, onProgress), (onProgress) => SessionManager.listAll(sessionDir, onProgress), settingsManager);
+            if (!selectedPath) {
+                console.log(chalk.dim("No session selected"));
+                process.exit(0);
+            }
+            return SessionManager.open(selectedPath, sessionDir);
+        }
+        finally {
+            stopThemeWatcher();
+        }
+    }
+    if (parsed.continue) {
+        return SessionManager.continueRecent(cwd, sessionDir);
+    }
+    if (parsed.sessionId) {
+        const existingSession = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
+        if (existingSession) {
+            return SessionManager.open(existingSession.path, sessionDir);
+        }
+        console.error(chalk.yellow(`Warning: No project session found with id '${parsed.sessionId}'; creating a new session with that id.`));
+    }
+    return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
+}
+export function applySessionName(parsed, sessionManager) {
+    if (parsed.name !== undefined) {
+        const name = parsed.name.trim();
+        if (!name) {
+            console.error(chalk.red("Error: --name requires a non-empty value"));
+            process.exit(1);
+        }
+        sessionManager.appendSessionInfo(name);
+    }
+}

package/dist/config.d.ts

@@ -67,6 +67,8 @@ export declare const APP_NAME: string;
 export declare const APP_TITLE: string;
 export declare const CONFIG_DIR_NAME: string;
 export declare const VERSION: string;
+/** Set by distribution staging, independently of the user's NODE_ENV. */
+export declare const IS_PRODUCTION_DISTRIBUTION: boolean;
 export declare const ENV_AGENT_DIR = "DIFFEX_CODING_AGENT_DIR";
 export declare const ENV_SESSION_DIR = "DIFFEX_CODING_AGENT_SESSION_DIR";
 export declare function expandTildePath(path: string): string;

package/dist/config.js

@@ -393,6 +393,8 @@ export const APP_NAME = diffexConfigName || "diffex";
 export const APP_TITLE = diffexConfigName ? APP_NAME : "Diffex";
 export const CONFIG_DIR_NAME = pkg.diffexConfig?.configDir || ".diffex";
 export const VERSION = pkg.version || "0.0.0";
+/** Set by distribution staging, independently of the user's NODE_ENV. */
+export const IS_PRODUCTION_DISTRIBUTION = isBunBinary || pkg.diffexConfig?.production === true;
 export const ENV_AGENT_DIR = "DIFFEX_CODING_AGENT_DIR";
 export const ENV_SESSION_DIR = "DIFFEX_CODING_AGENT_SESSION_DIR";
 export function expandTildePath(path) {

package/dist/core/extensions/factory.d.ts

@@ -0,0 +1,21 @@
+import type { EventBus } from "../event-bus.ts";
+import type { Extension, ExtensionAPI, ExtensionFactory, ExtensionRuntime } from "./types.ts";
+/**
+ * Create a runtime with throwing stubs for action methods.
+ * Runner.bindCore() replaces these with real implementations.
+ */
+export declare function createExtensionRuntime(): ExtensionRuntime;
+/**
+ * Create the ExtensionAPI for an extension.
+ * Registration methods write to the extension object.
+ * Action methods delegate to the shared runtime.
+ */
+export declare function createExtensionAPI(extension: Extension, runtime: ExtensionRuntime, cwd: string, eventBus: EventBus): ExtensionAPI;
+/**
+ * Create an Extension object with empty collections.
+ */
+export declare function createExtension(extensionPath: string, resolvedPath: string): Extension;
+/**
+ * Create an Extension from an inline factory function.
+ */
+export declare function loadExtensionFromFactory(factory: ExtensionFactory, cwd: string, eventBus: EventBus, runtime: ExtensionRuntime, extensionPath?: string): Promise<Extension>;

package/dist/core/extensions/factory.js

@@ -0,0 +1,254 @@
+import * as path from "node:path";
+import { resolvePath } from "../../utils/paths.js";
+import { execCommand } from "../exec.js";
+import { createSyntheticSourceInfo } from "../source-info.js";
+import { time } from "../timings.js";
+/**
+ * Create a runtime with throwing stubs for action methods.
+ * Runner.bindCore() replaces these with real implementations.
+ */
+export function createExtensionRuntime() {
+    const notInitialized = () => {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+    };
+    const state = {};
+    const eventBusUnsubscribers = new Set();
+    const assertActive = () => {
+        if (state.staleMessage) {
+            throw new Error(state.staleMessage);
+        }
+    };
+    const runtime = {
+        sendMessage: notInitialized,
+        sendUserMessage: notInitialized,
+        appendEntry: notInitialized,
+        setSessionName: notInitialized,
+        getSessionName: notInitialized,
+        setLabel: notInitialized,
+        getActiveTools: notInitialized,
+        getAllTools: notInitialized,
+        setActiveTools: notInitialized,
+        // registerTool() is valid during extension load; refresh is only needed post-bind.
+        refreshTools: () => { },
+        getCommands: notInitialized,
+        setModel: () => Promise.reject(new Error("Extension runtime not initialized")),
+        getThinkingLevel: notInitialized,
+        setThinkingLevel: notInitialized,
+        flagValues: new Map(),
+        pendingProviderRegistrations: [],
+        pendingNativeProviderRegistrations: [],
+        assertActive,
+        invalidate: (message) => {
+            if (state.staleMessage)
+                return;
+            state.staleMessage =
+                message ??
+                    "This extension ctx is stale after session replacement or reload. Do not use a captured Diffex API or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
+            for (const unsubscribe of eventBusUnsubscribers)
+                unsubscribe();
+            eventBusUnsubscribers.clear();
+        },
+        trackEventBusSubscription: (unsubscribe) => {
+            let active = true;
+            const trackedUnsubscribe = () => {
+                if (!active)
+                    return;
+                active = false;
+                eventBusUnsubscribers.delete(trackedUnsubscribe);
+                unsubscribe();
+            };
+            eventBusUnsubscribers.add(trackedUnsubscribe);
+            return trackedUnsubscribe;
+        },
+        // Pre-bind: queue registrations so bindCore() can flush them once the
+        // model registry is available. bindCore() replaces both with direct calls.
+        registerProvider: (name, config, extensionPath = "<unknown>") => {
+            runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
+        },
+        registerNativeProvider: (provider, extensionPath = "<unknown>") => {
+            runtime.pendingNativeProviderRegistrations.push({ provider, extensionPath });
+        },
+        unregisterProvider: (name) => {
+            runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter((r) => r.name !== name);
+            runtime.pendingNativeProviderRegistrations = runtime.pendingNativeProviderRegistrations.filter((r) => r.provider.id !== name);
+        },
+    };
+    return runtime;
+}
+/**
+ * Create the ExtensionAPI for an extension.
+ * Registration methods write to the extension object.
+ * Action methods delegate to the shared runtime.
+ */
+export function createExtensionAPI(extension, runtime, cwd, eventBus) {
+    const api = {
+        // Registration methods - write to extension
+        on(event, handler) {
+            runtime.assertActive();
+            const list = extension.handlers.get(event) ?? [];
+            list.push(handler);
+            extension.handlers.set(event, list);
+        },
+        registerTool(tool) {
+            runtime.assertActive();
+            extension.tools.set(tool.name, {
+                definition: tool,
+                sourceInfo: extension.sourceInfo,
+            });
+            runtime.refreshTools();
+        },
+        registerCommand(name, options) {
+            runtime.assertActive();
+            extension.commands.set(name, {
+                name,
+                sourceInfo: extension.sourceInfo,
+                ...options,
+            });
+        },
+        registerShortcut(shortcut, options) {
+            runtime.assertActive();
+            extension.shortcuts.set(shortcut, { shortcut, extensionPath: extension.path, ...options });
+        },
+        registerFlag(name, options) {
+            runtime.assertActive();
+            extension.flags.set(name, { name, extensionPath: extension.path, ...options });
+            if (options.default !== undefined && !runtime.flagValues.has(name)) {
+                runtime.flagValues.set(name, options.default);
+            }
+        },
+        registerMessageRenderer(customType, renderer) {
+            runtime.assertActive();
+            extension.messageRenderers.set(customType, renderer);
+        },
+        registerMarkdownTransformer(transformer) {
+            runtime.assertActive();
+            extension.markdownTransformer = transformer;
+        },
+        registerEntryRenderer(customType, renderer) {
+            runtime.assertActive();
+            extension.entryRenderers ??= new Map();
+            extension.entryRenderers.set(customType, renderer);
+        },
+        // Flag access - checks extension registered it, reads from runtime
+        getFlag(name) {
+            runtime.assertActive();
+            if (!extension.flags.has(name))
+                return undefined;
+            return runtime.flagValues.get(name);
+        },
+        // Action methods - delegate to shared runtime
+        sendMessage(message, options) {
+            runtime.assertActive();
+            runtime.sendMessage(message, options);
+        },
+        sendUserMessage(content, options) {
+            runtime.assertActive();
+            runtime.sendUserMessage(content, options);
+        },
+        appendEntry(customType, data) {
+            runtime.assertActive();
+            runtime.appendEntry(customType, data);
+        },
+        setSessionName(name) {
+            runtime.assertActive();
+            runtime.setSessionName(name);
+        },
+        getSessionName() {
+            runtime.assertActive();
+            return runtime.getSessionName();
+        },
+        setLabel(entryId, label) {
+            runtime.assertActive();
+            runtime.setLabel(entryId, label);
+        },
+        exec(command, args, options) {
+            runtime.assertActive();
+            return execCommand(command, args, options?.cwd ?? cwd, options);
+        },
+        getActiveTools() {
+            runtime.assertActive();
+            return runtime.getActiveTools();
+        },
+        getAllTools() {
+            runtime.assertActive();
+            return runtime.getAllTools();
+        },
+        setActiveTools(toolNames) {
+            runtime.assertActive();
+            runtime.setActiveTools(toolNames);
+        },
+        getCommands() {
+            runtime.assertActive();
+            return runtime.getCommands();
+        },
+        setModel(model) {
+            runtime.assertActive();
+            return runtime.setModel(model);
+        },
+        getThinkingLevel() {
+            runtime.assertActive();
+            return runtime.getThinkingLevel();
+        },
+        setThinkingLevel(level) {
+            runtime.assertActive();
+            runtime.setThinkingLevel(level);
+        },
+        registerProvider(providerOrName, config) {
+            runtime.assertActive();
+            if (typeof providerOrName === "string") {
+                if (!config)
+                    throw new Error("Provider config is required when registering by name");
+                runtime.registerProvider(providerOrName, config, extension.path);
+                return;
+            }
+            runtime.registerNativeProvider(providerOrName, extension.path);
+        },
+        unregisterProvider(name) {
+            runtime.assertActive();
+            runtime.unregisterProvider(name, extension.path);
+        },
+        events: {
+            emit(channel, data) {
+                runtime.assertActive();
+                eventBus.emit(channel, data);
+            },
+            on(channel, handler) {
+                runtime.assertActive();
+                return runtime.trackEventBusSubscription(eventBus.on(channel, handler));
+            },
+        },
+    };
+    return api;
+}
+/**
+ * Create an Extension object with empty collections.
+ */
+export function createExtension(extensionPath, resolvedPath) {
+    const source = extensionPath.startsWith("<") && extensionPath.endsWith(">")
+        ? extensionPath.slice(1, -1).split(":")[0] || "temporary"
+        : "local";
+    const baseDir = extensionPath.startsWith("<") ? undefined : path.dirname(resolvedPath);
+    return {
+        path: extensionPath,
+        resolvedPath,
+        sourceInfo: createSyntheticSourceInfo(extensionPath, { source, baseDir }),
+        handlers: new Map(),
+        tools: new Map(),
+        messageRenderers: new Map(),
+        entryRenderers: new Map(),
+        commands: new Map(),
+        flags: new Map(),
+        shortcuts: new Map(),
+    };
+}
+/**
+ * Create an Extension from an inline factory function.
+ */
+export async function loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath = "<inline>") {
+    const extension = createExtension(extensionPath, extensionPath);
+    const resolvedCwd = resolvePath(cwd);
+    const api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
+    await factory(api);
+    time(`${extensionPath} factory`, "extensions");
+    return extension;
+}

package/dist/core/extensions/loader.d.ts

@@ -3,17 +3,9 @@
  *
  */
 import { type EventBus } from "../event-bus.ts";
-import type { Extension, ExtensionFactory, ExtensionRuntime, LoadExtensionsResult } from "./types.ts";
+import type { ExtensionRuntime, LoadExtensionsResult } from "./types.ts";
+export { createExtensionRuntime, loadExtensionFromFactory } from "./factory.ts";
 export declare function clearExtensionCache(): void;
-/**
- * Create a runtime with throwing stubs for action methods.
- * Runner.bindCore() replaces these with real implementations.
- */
-export declare function createExtensionRuntime(): ExtensionRuntime;
-/**
- * Create an Extension from an inline factory function.
- */
-export declare function loadExtensionFromFactory(factory: ExtensionFactory, cwd: string, eventBus: EventBus, runtime: ExtensionRuntime, extensionPath?: string): Promise<Extension>;
 export declare function loadExtensions(paths: string[], cwd: string, eventBus?: EventBus, runtime?: ExtensionRuntime): Promise<LoadExtensionsResult>;
 export declare function loadExtensionsCached(paths: string[], cwd: string, eventBus?: EventBus, runtime?: ExtensionRuntime): Promise<LoadExtensionsResult>;
 /**