@oh-my-pi/pi-coding-agent 15.5.15 → 15.7.0

package/src/internal-urls/local-protocol.ts

@@ -5,7 +5,7 @@ import { isEnoent } from "@oh-my-pi/pi-utils";
 import { AgentRegistry } from "../registry/agent-registry";
 import { parseInternalUrl } from "./parse";
 import { validateRelativePath } from "./skill-protocol";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 export interface LocalProtocolOptions {
 	getArtifactsDir?: () => string | null;
@@ -246,4 +246,17 @@ export class LocalProtocolHandler implements ProtocolHandler {
 			notes: ["Use write path local://<file> to persist large intermediate artifacts across turns."],
 		};
 	}
+
+	async complete(): Promise<UrlCompletion[]> {
+		const opts = LocalProtocolHandler.resolveOptions();
+		if (!opts) return [];
+		const localRoot = path.resolve(resolveLocalRoot(opts));
+		try {
+			const files = await listFilesRecursively(localRoot);
+			return files.map(value => ({ value }));
+		} catch (err) {
+			if (isEnoent(err)) return [];
+			throw err;
+		}
+	}
 }

package/src/internal-urls/memory-protocol.ts

@@ -4,7 +4,7 @@ import { getAgentDir, isEnoent } from "@oh-my-pi/pi-utils";
 import { getMemoryRoot } from "../memories";
 import { AgentRegistry } from "../registry/agent-registry";
 import { validateRelativePath } from "./skill-protocol";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 const DEFAULT_MEMORY_FILE = "memory_summary.md";
 const MEMORY_NAMESPACE = "root";
@@ -161,4 +161,9 @@ export class MemoryProtocolHandler implements ProtocolHandler {
 
 		throw new Error(`Memory file not found: ${url.href}`);
 	}
+
+	async complete(): Promise<UrlCompletion[]> {
+		if (memoryRootsFromRegistry().length === 0) return [];
+		return [{ value: MEMORY_NAMESPACE, description: "Project memory summary" }];
+	}
 }

package/src/internal-urls/omp-protocol.ts

@@ -9,7 +9,7 @@
  */
 import * as path from "node:path";
 import { EMBEDDED_DOC_FILENAMES, EMBEDDED_DOCS } from "./docs-index.generated";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 /**
  * Handler for omp:// URLs.
@@ -33,6 +33,10 @@ export class OmpProtocolHandler implements ProtocolHandler {
 		return this.#readDoc(filename, url);
 	}
 
+	async complete(): Promise<UrlCompletion[]> {
+		return EMBEDDED_DOC_FILENAMES.map(value => ({ value }));
+	}
+
 	async #listDocs(url: InternalUrl): Promise<InternalResource> {
 		if (EMBEDDED_DOC_FILENAMES.length === 0) {
 			throw new Error("No documentation files found");

package/src/internal-urls/router.ts

@@ -15,7 +15,7 @@ import { OmpProtocolHandler } from "./omp-protocol";
 import { parseInternalUrl } from "./parse";
 import { RuleProtocolHandler } from "./rule-protocol";
 import { SkillProtocolHandler } from "./skill-protocol";
-import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
 import { VaultProtocolHandler } from "./vault-protocol";
 
 export class InternalUrlRouter {
@@ -66,6 +66,25 @@ export class InternalUrlRouter {
 		return this.#handlers.has(match[1].toLowerCase());
 	}
 
+	/** Schemes whose handler supports host/path autocomplete. */
+	completionSchemes(): string[] {
+		const schemes: string[] = [];
+		for (const [scheme, handler] of this.#handlers) {
+			if (handler.complete) schemes.push(scheme);
+		}
+		return schemes;
+	}
+
+	/**
+	 * Candidate completions for the host/path portion of `scheme://<query>`.
+	 * Returns `null` when the scheme is unknown or does not support completion.
+	 */
+	async complete(scheme: string, query: string): Promise<UrlCompletion[] | null> {
+		const handler = this.#handlers.get(scheme.toLowerCase());
+		if (!handler?.complete) return null;
+		return handler.complete(query);
+	}
+
 	async resolve(input: string, context?: ResolveContext): Promise<InternalResource> {
 		const parsed = parseInternalUrl(input);
 		const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();

package/src/internal-urls/rule-protocol.ts

@@ -5,7 +5,7 @@
  * - rule://<name> - Reads rule content
  */
 import { getActiveRules } from "../capability/rule";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 export class RuleProtocolHandler implements ProtocolHandler {
 	readonly scheme = "rule";
@@ -35,4 +35,11 @@ export class RuleProtocolHandler implements ProtocolHandler {
 			notes: [],
 		};
 	}
+
+	async complete(): Promise<UrlCompletion[]> {
+		return getActiveRules().map(rule => ({
+			value: rule.name,
+			...(rule.description ? { description: rule.description } : {}),
+		}));
+	}
 }

package/src/internal-urls/skill-protocol.ts

@@ -9,7 +9,7 @@
  */
 import * as path from "node:path";
 import { getActiveSkills } from "../extensibility/skills";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 function getContentType(filePath: string): InternalResource["contentType"] {
 	const ext = path.extname(filePath).toLowerCase();
@@ -86,4 +86,11 @@ export class SkillProtocolHandler implements ProtocolHandler {
 			notes: [],
 		};
 	}
+
+	async complete(): Promise<UrlCompletion[]> {
+		return getActiveSkills().map(skill => ({
+			value: skill.name,
+			...(skill.description ? { description: skill.description } : {}),
+		}));
+	}
 }

package/src/internal-urls/types.ts

@@ -32,6 +32,22 @@ export interface InternalResource {
 	immutable?: boolean;
 }
 
+/**
+ * A single autocomplete candidate for the host/path portion of a `scheme://`
+ * URL, produced by {@link ProtocolHandler.complete}.
+ */
+export interface UrlCompletion {
+	/**
+	 * The text that follows `scheme://` for this candidate (e.g. `humanizer`,
+	 * `subdir/data.json`, `root`). The caller renders it as `scheme://<value>`.
+	 */
+	value: string;
+	/** Human-facing label for the dropdown. Defaults to {@link value}. */
+	label?: string;
+	/** Optional one-line description shown beside the candidate. */
+	description?: string;
+}
+
 /**
  * Parsed internal URL with preserved host casing.
  */
@@ -107,4 +123,15 @@ export interface ProtocolHandler {
 	 * surfaces a clear "not writable" error when invoked against them.
 	 */
 	write?(url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
+	/**
+	 * Optional autocomplete hook. Returns candidate completions for the
+	 * host/path portion of a `scheme://` URL while the user composes a prompt.
+	 *
+	 * Implementations **MUST** be fast and local — this runs on every keystroke.
+	 * Schemes backed by network or external CLIs (issue://, pr://, vault://,
+	 * mcp://) omit it. The caller fuzzy-filters the returned set against the
+	 * partially typed `query`, so handlers return their full (bounded) candidate
+	 * list; `query` is provided only so handlers can scope expensive enumeration.
+	 */
+	complete?(query: string): Promise<UrlCompletion[]>;
 }

package/src/lsp/render.ts

@@ -103,7 +103,7 @@ export function renderResult(
 	args?: LspParams,
 ): Component {
 	const content = result.content?.[0];
-	if (!content || content.type !== "text" || !("text" in content) || !content.text) {
+	if (content?.type !== "text" || !("text" in content) || !content.text) {
 		const icon = formatStatusIcon("warning", theme, options.spinnerFrame);
 		const header = `${icon} LSP`;
 		return new Text([header, theme.fg("dim", "No result")].join("\n"), 0, 0);

package/src/main.ts

@@ -49,6 +49,7 @@ import {
 } from "./extensibility/plugins/marketplace";
 import type { MCPManager } from "./mcp";
 import { InteractiveMode, runAcpMode, runPrintMode, runRpcMode } from "./modes";
+import { ALL_SCENES, runSetupWizard, selectSetupScenes } from "./modes/setup-wizard";
 import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
 import {
@@ -257,6 +258,8 @@ async function runInteractiveMode(
 	setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
 	lspServers: LspStartupServerInfo[] | undefined,
 	mcpManager: MCPManager | undefined,
+	resuming: boolean,
+	forceSetupWizard: boolean,
 	eventBus?: EventBus,
 	initialMessage?: string,
 	initialImages?: ImageContent[],
@@ -271,7 +274,18 @@ async function runInteractiveMode(
 		eventBus,
 	);
 
-	await mode.init();
+	const setupScenes = await selectSetupScenes(settings.get("setupVersion"), ALL_SCENES, mode, {
+		resuming,
+		isTTY: process.stdin.isTTY && process.stdout.isTTY,
+		setupWizardEnabled: settings.get("startup.setupWizard"),
+		force: forceSetupWizard,
+	});
+
+	await mode.init({ suppressWelcomeIntro: setupScenes.length > 0 });
+
+	if (setupScenes.length > 0) {
+		await runSetupWizard(mode, setupScenes);
+	}
 
 	versionCheckPromise
 		.then(newVersion => {
@@ -693,6 +707,7 @@ interface RunRootCommandDependencies {
 	discoverAuthStorage?: typeof discoverAuthStorage;
 	runAcpMode?: typeof runAcpMode;
 	settings?: Settings;
+	forceSetupWizard?: boolean;
 }
 
 export async function runRootCommand(
@@ -1028,6 +1043,8 @@ export async function runRootCommand(
 				setToolUIContext,
 				lspServers,
 				mcpManager,
+				Boolean(parsedArgs.continue || parsedArgs.resume || parsedArgs.fork),
+				deps.forceSetupWizard === true,
 				eventBus,
 				initialMessage,
 				initialImages,

package/src/mcp/oauth-flow.ts

@@ -42,7 +42,7 @@ function getUriPort(uri: URL): number {
 
 function validateRedirectConfig(config: MCPOAuthConfig, redirectUri: string | undefined): void {
 	const parsed = parseRedirectUri(redirectUri);
-	if (!parsed || parsed.protocol !== "https:" || !isLoopbackHostname(parsed.hostname)) {
+	if (parsed?.protocol !== "https:" || !isLoopbackHostname(parsed.hostname)) {
 		return;
 	}
 
@@ -63,7 +63,7 @@ function resolveCallbackPort(callbackPort: number | undefined, redirectUri: stri
 	if (callbackPort !== undefined) return callbackPort;
 
 	const parsed = parseRedirectUri(redirectUri);
-	if (!parsed || parsed.protocol !== "http:" || !isLoopbackHostname(parsed.hostname)) {
+	if (parsed?.protocol !== "http:" || !isLoopbackHostname(parsed.hostname)) {
 		return DEFAULT_PORT;
 	}
 

package/src/memory-backend/index.ts

@@ -1,3 +1,4 @@
+export * from "../mnemosyne";
 export * from "./local-backend";
 export * from "./off-backend";
 export * from "./resolve";

package/src/memory-backend/resolve.ts

@@ -1,5 +1,6 @@
 import type { Settings } from "../config/settings";
 import { hindsightBackend } from "../hindsight";
+import { mnemosyneBackend } from "../mnemosyne";
 import { localBackend } from "./local-backend";
 import { offBackend } from "./off-backend";
 import type { MemoryBackend } from "./types";
@@ -10,7 +11,8 @@ import type { MemoryBackend } from "./types";
  * Selection rules (single source of truth — every memory consumer routes
  * through this):
  *   - `memory.backend === "hindsight"`  → Hindsight remote memory
- *   - `memory.backend === "local"`      → local pipeline
+ *   - `memory.backend === "mnemosyne"`  → local Mnemosyne SQLite memory
+ *   - `memory.backend === "local"`      → local rollout summary pipeline
  *   - everything else                   → no-op
  *
  * `memories.enabled` remains accepted only as a legacy migration input. Once
@@ -19,6 +21,7 @@ import type { MemoryBackend } from "./types";
 export function resolveMemoryBackend(settings: Settings): MemoryBackend {
 	const id = settings.get("memory.backend");
 	if (id === "hindsight") return hindsightBackend;
+	if (id === "mnemosyne") return mnemosyneBackend;
 	if (id === "local") return localBackend;
 	return offBackend;
 }

package/src/memory-backend/types.ts

@@ -10,9 +10,10 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
 import type { HindsightSessionState } from "../hindsight/state";
+import type { MnemosyneSessionState } from "../mnemosyne/state";
 import type { AgentSession } from "../session/agent-session";
 
-export type MemoryBackendId = "off" | "local" | "hindsight";
+export type MemoryBackendId = "off" | "local" | "hindsight" | "mnemosyne";
 
 export interface MemoryBackendStartOptions {
 	session: AgentSession;
@@ -21,6 +22,7 @@ export interface MemoryBackendStartOptions {
 	agentDir: string;
 	taskDepth: number;
 	parentHindsightSessionState?: HindsightSessionState;
+	parentMnemosyneSessionState?: MnemosyneSessionState;
 }
 
 export interface MemoryBackend {
@@ -51,6 +53,11 @@ export interface MemoryBackend {
 	/** Force consolidation/retain to happen now (slash `/memory enqueue`). */
 	enqueue(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
 
+	/** Render backend-specific memory statistics as markdown (`/memory stats`). */
+	stats?(agentDir: string, cwd: string, session?: AgentSession): Promise<string | undefined>;
+
+	/** Render backend-specific memory diagnostics as markdown (`/memory diagnose`). */
+	diagnose?(agentDir: string, cwd: string, session?: AgentSession): Promise<string | undefined>;
 	/**
 	 * Optional hook to inject a backend-specific block into the current turn's
 	 * system prompt before the agent starts generating.