@oh-my-pi/pi-coding-agent 12.0.0 → 12.1.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [12.1.0] - 2026-02-13
+
+### Added
+
+- Filesystem scan cache invalidation helpers (`invalidateFsScanAfterWrite`, `invalidateFsScanAfterDelete`, `invalidateFsScanAfterRename`) to properly invalidate shared caches after file mutations
+- Named discovery profile for file mention candidates to standardize cache visibility and ignore semantics across callers
+- Comprehensive `models.yml` provider integration guide documenting custom model registration, provider overrides, API adapters, merge behavior, and practical integration patterns for Ollama, vLLM, LM Studio, and proxy endpoints
+- Claude Code marketplace plugin discovery: automatically loads skills, commands, hooks, tools, and agents from `~/.claude/plugins/cache/` based on `installed_plugins.json` registry ([#48](https://github.com/can1357/oh-my-pi/issues/48))
+
+### Changed
+
+- Moved directory path utilities from `src/config.ts` to `@oh-my-pi/pi-utils/dirs` for shared use across packages
+- Updated imports throughout codebase to use centralized directory path functions from `@oh-my-pi/pi-utils/dirs`
+- Updated interactive bash terminal UI label from 'InteractiveTerm' to 'Console' for clarity
+- Enhanced bash execution environment with comprehensive non-interactive defaults for pagers, editors, and package managers to prevent command blocking and interactive prompts
+- Updated custom models configuration to use `~/.omp/agent/models.yml` (YAML format) while maintaining backward compatibility with legacy `models.json`
+
 ## [12.0.0] - 2026-02-12
 
 ### Added

package/README.md

@@ -447,7 +447,9 @@ The `--system-prompt` CLI flag overrides both files. Use `--append-system-prompt
 
 ### Custom Models and Providers
 
-Add custom models (Ollama, vLLM, LM Studio, etc.) via `~/.omp/agent/models.json`:
+Add custom models (Ollama, vLLM, LM Studio, etc.) via `~/.omp/agent/models.yml` (`models.json` is still supported for legacy configs):
+
+> See [models.yml provider integration guide](docs/models.md) for full schema, merge behavior, and provider integration patterns.
 
 ```json
 {
@@ -750,7 +752,7 @@ export default function (omp: HookAPI) {
 						content,
 						display: true,
 					},
-					true
+					true,
 				); // triggerTurn: start agent loop
 			}
 		});
@@ -1035,33 +1037,6 @@ Omp is a fork of [Pi](https://github.com/badlogic/pi) by [Mario Zechner](https:/
 
 ## Development
 
-### Forking / Rebranding
-
-Configure via `package.json`:
-
-```json
-{
-	"ompConfig": {
-		"name": "omp",
-		"configDir": ".omp"
-	}
-}
-```
-
-Change `name`, `configDir`, and `bin` field for your fork. Affects CLI banner, config paths, and environment variable names.
-
-### Path Resolution
-
-Three execution modes: npm install, standalone binary, tsx from source.
-
-**Always use `src/config.ts`** for package assets:
-
-```typescript
-import { getPackageDir } from "./config.js";
-```
-
-Never use `__dirname` directly for package assets.
-
 ### Debug Command
 
 `/debug` (hidden) writes rendered lines with ANSI codes to `~/.omp/agent/omp-debug.log` for TUI debugging, as well as the last set of messages that were sent to the LLM.

package/docs/fs-scan-cache-architecture.md

@@ -0,0 +1,50 @@
+# FS scan cache architecture
+
+This document defines the shared filesystem-scan cache contract used by `pi-natives` discovery/search callers.
+
+## Cache key contract
+
+Cache entries are keyed by:
+
+- `root` (absolute search root path)
+- `include_hidden` (hidden-file visibility)
+- `use_gitignore` (ignore-rule behavior)
+
+Callers with different visibility/ignore semantics must use different profiles so they do not share incompatible cache entries.
+
+## Freshness and recheck contract
+
+`crates/pi-natives/src/fs_cache.rs` owns global policy:
+
+- `FS_SCAN_CACHE_TTL_MS` (default `1000`)
+- `FS_SCAN_EMPTY_RECHECK_MS` (default `200`)
+- `FS_SCAN_CACHE_MAX_ENTRIES` (default `16`)
+
+`get_or_scan()` returns `cache_age_ms` so callers can decide whether an empty filtered result should trigger `force_rescan()`.
+
+Current callers using this contract:
+
+- `fd` (`fuzzyFind`) uses empty-result fast recheck.
+- `grep` consumes shared scan entries and applies grep-specific glob/type filtering on top.
+
+## Invalidation contract
+
+Mutation-triggered invalidation is explicit and path-based via `invalidateFsScanCache`.
+
+Coding-agent routes invalidation through `packages/coding-agent/src/tools/fs-cache-invalidation.ts`:
+
+- `invalidateFsScanAfterWrite(path)`
+- `invalidateFsScanAfterDelete(path)`
+- `invalidateFsScanAfterRename(oldPath, newPath)` (invalidates both paths)
+
+Write/edit flows call these helpers after successful filesystem mutation.
+
+## Caller discovery profiles
+
+Callers should not build ad-hoc discovery flags inline. Use named profile/policy helpers at callsites.
+
+Current profile boundaries:
+
+- File mention candidate discovery (`file-mentions.ts`): hidden on, gitignore on, node_modules included.
+- TUI fuzzy `@` discovery (`autocomplete.ts`): hidden on, gitignore on, bounded result count.
+- TUI local path prefix completion keeps a separate per-directory `readdir` cache as an intentional latency fast-path; global fuzzy discovery remains on natives shared scan cache.

package/docs/models.md

@@ -0,0 +1,234 @@
+# `models.yml` provider integration guide
+
+`models.yml` lets you register custom model providers (local or hosted), override built-in providers, and tune model metadata.
+
+Default location:
+
+- `~/.omp/agent/models.yml`
+
+Legacy support:
+
+- `models.json` is still read and auto-migrated to `models.yml` when possible.
+
+## Top-level shape
+
+```yaml
+providers:
+  <provider-name>:
+    # Provider config
+```
+
+`<provider-name>` is the provider ID used everywhere else (selection, auth lookup, etc.).
+
+## Provider fields
+
+```yaml
+providers:
+  my-provider:
+    baseUrl: https://api.example.com/v1
+    apiKey: MY_PROVIDER_API_KEY
+    api: openai-responses
+    headers:
+      X-Custom-Header: value
+    authHeader: true
+    auth: apiKey
+    discovery:
+      type: ollama
+    modelOverrides:
+      <model-id-within-provider>:
+        name: Friendly Name
+    models:
+      - id: model-id
+        name: My Model
+        api: openai-responses
+        reasoning: false
+        input: [text]
+        cost:
+          input: 0
+          output: 0
+          cacheRead: 0
+          cacheWrite: 0
+        contextWindow: 128000
+        maxTokens: 16384
+        headers:
+          X-Model-Header: value
+        compat:
+          supportsStore: true
+          supportsDeveloperRole: true
+          supportsReasoningEffort: true
+          maxTokensField: max_completion_tokens
+          openRouterRouting:
+            only: [anthropic]
+          vercelGatewayRouting:
+            order: [openai, anthropic]
+```
+
+### `api` values
+
+Supported API adapters:
+
+- `openai-completions`
+- `openai-responses`
+- `openai-codex-responses`
+- `azure-openai-responses`
+- `anthropic-messages`
+- `google-generative-ai`
+- `google-vertex`
+
+`auth` values:
+
+- `apiKey` (default)
+- `none`
+
+`discovery.type` values:
+
+- `ollama`
+
+If `discovery` is set, provider-level `api` is required.
+
+## Required vs optional
+
+### Full custom provider (defines `models`)
+
+If `models` is non-empty, you must set:
+
+- `baseUrl`
+- `apiKey` (unless `auth: none`)
+- `api` at provider level or per model
+
+If `auth: none` is set, `apiKey` is optional even when `models` are defined.
+
+### Override-only provider (no `models`)
+
+If `models` is empty/missing, set at least one of:
+
+- `baseUrl`
+- `modelOverrides`
+- `discovery`
+
+Use this to modify built-in providers without redefining all models.
+
+Default values when omitted in a model definition:
+
+- `reasoning: false`
+- `input: [text]`
+- `cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }`
+- `contextWindow: 128000`
+- `maxTokens: 16384`
+
+Header merge behavior:
+
+- Provider `headers` are applied first
+- Model-level `headers` override provider headers on key conflicts
+## Merge behavior
+
+`models.yml` does not replace the built-in registry.
+
+1. Built-in models load first.
+2. Provider-level overrides (`baseUrl`, `headers`) are applied.
+3. `modelOverrides` are applied by model ID within each provider.
+4. Custom `models` are merged in.
+5. If a custom model has the same `provider + id` as an existing model, it replaces that model.
+
+## API key behavior
+
+`apiKey` resolution is:
+
+1. Treat value as env var name (preferred)
+2. If env var not found, treat value as literal key
+
+Example:
+
+```yaml
+apiKey: OPENROUTER_API_KEY
+```
+
+If `OPENROUTER_API_KEY` exists, that value is used. Otherwise, the literal string `OPENROUTER_API_KEY` is used as the token.
+
+Use `authHeader: true` when your endpoint expects:
+
+```http
+Authorization: Bearer <apiKey>
+```
+
+Set `auth: none` for keyless providers (local gateways, unauthenticated dev endpoints).
+
+## Practical integration patterns
+
+### 1) OpenAI-compatible endpoint (vLLM / LM Studio / gateway)
+
+```yaml
+providers:
+  local-openai:
+    baseUrl: http://127.0.0.1:8000/v1
+    auth: none
+    api: openai-completions
+    models:
+      - id: Qwen/Qwen2.5-Coder-32B-Instruct
+        name: Qwen 2.5 Coder 32B (local)
+```
+
+### 2) Anthropic-compatible proxy
+
+```yaml
+providers:
+  anthropic-proxy:
+    baseUrl: https://proxy.example.com/anthropic
+    apiKey: ANTHROPIC_PROXY_KEY
+    api: anthropic-messages
+    authHeader: true
+    models:
+      - id: claude-sonnet-4-20250514
+        name: Claude Sonnet 4 (Proxy)
+        reasoning: true
+        input: [text, image]
+```
+
+### 3) Override built-in provider without redefining models
+
+```yaml
+providers:
+  openrouter:
+    baseUrl: https://my-corp-proxy.example.com/v1
+    headers:
+      X-Team: platform
+    modelOverrides:
+      anthropic/claude-sonnet-4:
+        name: Sonnet 4 (Corp Route)
+```
+
+### 4) Runtime discovery for Ollama
+
+```yaml
+providers:
+  ollama:
+    baseUrl: http://127.0.0.1:11434
+    api: openai-completions
+    auth: none
+    discovery:
+      type: ollama
+```
+
+The agent will query `GET /api/tags` and register discovered models dynamically.
+
+## Validation failures to watch for
+
+Common schema/validation errors:
+
+- Provider with `models` but missing `baseUrl`
+- Provider with `models` and `auth != none` but missing `apiKey`
+- Model missing `api` when neither provider-level nor model-level `api` is set
+- Non-positive `contextWindow` or `maxTokens`
+- `discovery` configured without provider-level `api`
+
+When `models.yml` has errors, the agent falls back to built-in models and reports a load error.
+
+## Quick start
+
+1. Create `~/.omp/agent/models.yml`
+2. Add one provider with one model
+3. Start the agent and open `/model`
+4. Confirm your provider/model appears
+5. If auth fails, check env vars and `authHeader`
+
+For SDK usage, `ModelRegistry` also accepts a custom path so you can load non-default `models.yml` files programmatically.

package/package.json

@@ -1,12 +1,8 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "12.0.0",
+	"version": "12.1.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
-	"ompConfig": {
-		"name": "omp",
-		"configDir": ".omp"
-	},
 	"bin": {
 		"omp": "src/cli.ts"
 	},
@@ -88,12 +84,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "12.0.0",
-		"@oh-my-pi/pi-agent-core": "12.0.0",
-		"@oh-my-pi/pi-ai": "12.0.0",
-		"@oh-my-pi/pi-natives": "12.0.0",
-		"@oh-my-pi/pi-tui": "12.0.0",
-		"@oh-my-pi/pi-utils": "12.0.0",
+		"@oh-my-pi/omp-stats": "12.1.0",
+		"@oh-my-pi/pi-agent-core": "12.1.0",
+		"@oh-my-pi/pi-ai": "12.1.0",
+		"@oh-my-pi/pi-natives": "12.1.0",
+		"@oh-my-pi/pi-tui": "12.1.0",
+		"@oh-my-pi/pi-utils": "12.1.0",
 		"@sinclair/typebox": "^0.34.48",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.17.1",

package/src/cli/args.ts

@@ -3,8 +3,8 @@
  */
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { logger } from "@oh-my-pi/pi-utils";
+import { APP_NAME, CONFIG_DIR_NAME } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
-import { APP_NAME, CONFIG_DIR_NAME } from "../config";
 import { BUILTIN_TOOLS } from "../tools";
 
 export type Mode = "text" | "json" | "rpc";

package/src/cli/config-cli.ts

@@ -4,8 +4,9 @@
  * Handles `omp config <command>` subcommands for managing settings.
  * Uses settings-defs as the source of truth for available settings.
  */
+
+import { APP_NAME, getAgentDir } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
-import { APP_NAME, getAgentDir } from "../config";
 import {
 	getDefault,
 	getEnumValues,

package/src/cli/grep-cli.ts

@@ -5,8 +5,8 @@
  */
 import * as path from "node:path";
 import { grep } from "@oh-my-pi/pi-natives";
+import { APP_NAME } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
-import { APP_NAME } from "../config";
 
 export interface GrepCommandArgs {
 	pattern: string;

package/src/cli/jupyter-cli.ts

@@ -3,8 +3,9 @@
  *
  * Handles `omp jupyter` subcommand for managing the shared Python gateway.
  */
+
+import { APP_NAME } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
-import { APP_NAME } from "../config";
 import { getGatewayStatus, shutdownSharedGateway } from "../ipy/gateway-coordinator";
 
 export type JupyterAction = "kill" | "status";

package/src/cli/plugin-cli.ts

@@ -3,8 +3,9 @@
  *
  * Handles `omp plugin <command>` subcommands for plugin lifecycle management.
  */
+
+import { APP_NAME } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
-import { APP_NAME } from "../config";
 import { PluginManager, parseSettingValue, validateSetting } from "../extensibility/plugins";
 import { theme } from "../modes/theme/theme";
 

package/src/cli/setup-cli.ts

@@ -3,9 +3,10 @@
  *
  * Handles `omp setup <component>` to install dependencies for optional features.
  */
+import * as path from "node:path";
+import { APP_NAME, getPythonEnvDir } from "@oh-my-pi/pi-utils/dirs";
 import { $ } from "bun";
 import chalk from "chalk";
-import { APP_NAME } from "../config";
 import { theme } from "../modes/theme/theme";
 
 export type SetupComponent = "python";
@@ -21,6 +22,7 @@ export interface SetupCommandArgs {
 const VALID_COMPONENTS: SetupComponent[] = ["python"];
 
 const PYTHON_PACKAGES = ["jupyter_kernel_gateway", "ipykernel"];
+const MANAGED_PYTHON_ENV = getPythonEnvDir();
 
 /**
  * Parse setup subcommand arguments.
@@ -67,6 +69,14 @@ interface PythonCheckResult {
 	pipPath?: string;
 	missingPackages: string[];
 	installedPackages: string[];
+	usingManagedEnv?: boolean;
+	managedEnvPath?: string;
+}
+
+function managedPythonPath(): string {
+	return process.platform === "win32"
+		? path.join(MANAGED_PYTHON_ENV, "Scripts", "python.exe")
+		: path.join(MANAGED_PYTHON_ENV, "bin", "python");
 }
 
 /**
@@ -77,48 +87,115 @@ async function checkPythonSetup(): Promise<PythonCheckResult> {
 		available: false,
 		missingPackages: [],
 		installedPackages: [],
+		managedEnvPath: MANAGED_PYTHON_ENV,
 	};
 
-	const pythonPath = Bun.which("python") ?? Bun.which("python3");
-	if (!pythonPath) {
-		return result;
-	}
-	result.pythonPath = pythonPath;
+	const systemPythonPath = Bun.which("python") ?? Bun.which("python3");
+	const managedPath = managedPythonPath();
+	const hasManagedEnv = await Bun.file(managedPath).exists();
+
 	result.uvPath = Bun.which("uv") ?? undefined;
 	result.pipPath = Bun.which("pip3") ?? Bun.which("pip") ?? undefined;
 
-	for (const pkg of PYTHON_PACKAGES) {
-		const moduleName = pkg === "jupyter_kernel_gateway" ? "kernel_gateway" : pkg;
-		const script = `import importlib.util; raise SystemExit(0 if importlib.util.find_spec('${moduleName}') else 1)`;
-		const check = await $`${pythonPath} -c ${script}`.quiet().nothrow();
-		if (check.exitCode === 0) {
-			result.installedPackages.push(pkg);
-		} else {
-			result.missingPackages.push(pkg);
+	const candidates = [systemPythonPath, hasManagedEnv ? managedPath : undefined].filter(
+		(candidate): candidate is string => !!candidate,
+	);
+	if (candidates.length === 0) {
+		return result;
+	}
+
+	result.pythonPath = systemPythonPath ?? managedPath;
+	let bestMatch = {
+		pythonPath: candidates[0],
+		missingPackages: [...PYTHON_PACKAGES],
+		installedPackages: [] as string[],
+		usingManagedEnv: candidates[0] === managedPath,
+	};
+
+	for (const pythonPath of candidates) {
+		const installedPackages: string[] = [];
+		const missingPackages: string[] = [];
+		for (const pkg of PYTHON_PACKAGES) {
+			const moduleName = pkg === "jupyter_kernel_gateway" ? "kernel_gateway" : pkg;
+			const script = `import importlib.util; raise SystemExit(0 if importlib.util.find_spec('${moduleName}') else 1)`;
+			const check = await $`${pythonPath} -c ${script}`.quiet().nothrow();
+			if (check.exitCode === 0) {
+				installedPackages.push(pkg);
+			} else {
+				missingPackages.push(pkg);
+			}
+		}
+
+		if (missingPackages.length < bestMatch.missingPackages.length) {
+			bestMatch = {
+				pythonPath,
+				missingPackages,
+				installedPackages,
+				usingManagedEnv: pythonPath === managedPath,
+			};
+		}
+
+		if (missingPackages.length === 0) {
+			result.available = true;
+			result.pythonPath = pythonPath;
+			result.missingPackages = missingPackages;
+			result.installedPackages = installedPackages;
+			result.usingManagedEnv = pythonPath === managedPath;
+			return result;
 		}
 	}
 
-	result.available = result.missingPackages.length === 0;
+	result.pythonPath = bestMatch.pythonPath;
+	result.missingPackages = bestMatch.missingPackages;
+	result.installedPackages = bestMatch.installedPackages;
+	result.usingManagedEnv = bestMatch.usingManagedEnv;
 	return result;
 }
 
 /**
  * Install Python packages using uv (preferred) or pip.
  */
-async function installPythonPackages(packages: string[], uvPath?: string, pipPath?: string): Promise<boolean> {
+async function installPythonPackages(
+	packages: string[],
+	pythonPath: string,
+	uvPath?: string,
+	pipPath?: string,
+): Promise<{ success: boolean; usedManagedEnv: boolean }> {
 	if (uvPath) {
 		console.log(chalk.dim(`Installing via uv: ${packages.join(" ")}`));
 		const result = await $`${uvPath} pip install ${packages}`.nothrow();
-		return result.exitCode === 0;
+		if (result.exitCode === 0) {
+			return { success: true, usedManagedEnv: false };
+		}
 	}
 
 	if (pipPath) {
 		console.log(chalk.dim(`Installing via pip: ${packages.join(" ")}`));
 		const result = await $`${pipPath} install ${packages}`.nothrow();
-		return result.exitCode === 0;
+		if (result.exitCode === 0) {
+			return { success: true, usedManagedEnv: false };
+		}
+	}
+
+	console.log(chalk.dim(`Falling back to managed virtual environment: ${MANAGED_PYTHON_ENV}`));
+
+	if (uvPath) {
+		const createEnv = await $`${uvPath} venv ${MANAGED_PYTHON_ENV}`.quiet().nothrow();
+		if (createEnv.exitCode !== 0) {
+			return { success: false, usedManagedEnv: true };
+		}
+		const installInManagedEnv = await $`${uvPath} pip install --python ${MANAGED_PYTHON_ENV} ${packages}`.nothrow();
+		return { success: installInManagedEnv.exitCode === 0, usedManagedEnv: true };
+	}
+
+	const createEnv = await $`${pythonPath} -m venv ${MANAGED_PYTHON_ENV}`.quiet().nothrow();
+	if (createEnv.exitCode !== 0) {
+		return { success: false, usedManagedEnv: true };
 	}
 
-	return false;
+	const managedPython = managedPythonPath();
+	const installInManagedEnv = await $`${managedPython} -m pip install ${packages}`.nothrow();
+	return { success: installInManagedEnv.exitCode === 0, usedManagedEnv: true };
 }
 
 /**
@@ -148,6 +225,9 @@ async function handlePythonSetup(flags: { json?: boolean; check?: boolean }): Pr
 	}
 
 	console.log(chalk.dim(`Python: ${check.pythonPath}`));
+	if (check.usingManagedEnv) {
+		console.log(chalk.dim(`Using managed environment: ${check.managedEnvPath}`));
+	}
 
 	if (check.uvPath) {
 		console.log(chalk.dim(`uv: ${check.uvPath}`));
@@ -178,18 +258,33 @@ async function handlePythonSetup(flags: { json?: boolean; check?: boolean }): Pr
 	}
 
 	console.log("");
-	const success = await installPythonPackages(check.missingPackages, check.uvPath, check.pipPath);
+	const install = await installPythonPackages(check.missingPackages, check.pythonPath, check.uvPath, check.pipPath);
 
-	if (!success) {
+	if (!install.success) {
 		console.error(chalk.red(`\n${theme.status.error} Installation failed`));
 		console.error(chalk.dim("Try installing manually:"));
-		console.error(chalk.dim(`  ${check.uvPath ? "uv pip" : "pip"} install ${check.missingPackages.join(" ")}`));
+		if (install.usedManagedEnv) {
+			if (check.uvPath) {
+				console.error(chalk.dim(`  uv venv ${MANAGED_PYTHON_ENV}`));
+				console.error(
+					chalk.dim(`  uv pip install --python ${MANAGED_PYTHON_ENV} ${check.missingPackages.join(" ")}`),
+				);
+			} else {
+				console.error(chalk.dim(`  ${check.pythonPath} -m venv ${MANAGED_PYTHON_ENV}`));
+				console.error(chalk.dim(`  ${managedPythonPath()} -m pip install ${check.missingPackages.join(" ")}`));
+			}
+		} else {
+			console.error(chalk.dim(`  ${check.uvPath ? "uv pip" : "pip"} install ${check.missingPackages.join(" ")}`));
+		}
 		process.exit(1);
 	}
 
 	const recheck = await checkPythonSetup();
 	if (recheck.available) {
 		console.log(chalk.green(`\n${theme.status.success} Python execution is ready`));
+		if (recheck.usingManagedEnv) {
+			console.log(chalk.dim(`Managed Python environment: ${recheck.managedEnvPath}`));
+		}
 	} else {
 		console.error(chalk.red(`\n${theme.status.error} Setup incomplete`));
 		console.error(chalk.dim(`Still missing: ${recheck.missingPackages.join(", ")}`));

package/src/cli/shell-cli.ts

@@ -6,8 +6,8 @@
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
 import { Shell } from "@oh-my-pi/pi-natives";
+import { APP_NAME } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
-import { APP_NAME } from "../config";
 import { Settings } from "../config/settings";
 import { getOrCreateSnapshot } from "../utils/shell-snapshot";
 

package/src/cli/stats-cli.ts

@@ -3,8 +3,9 @@
  *
  * Handles `omp stats` subcommand for viewing AI usage statistics.
  */
+
+import { APP_NAME } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
-import { APP_NAME } from "../config";
 import { openPath } from "../utils/open";
 
 // =============================================================================