pi-extmgr 0.1.8 → 0.1.9

package/README.md

@@ -1,6 +1,6 @@
 # pi-extmgr
 
-<img width="2560" height="369" alt="image" src="https://i.imgur.com/7ifGp5x.png" />
+<img width="2560" height="369" alt="image" src="https://i.imgur.com/bVM7ZcO.png" />
 
 [![CI](https://github.com/ayagmar/pi-extmgr/actions/workflows/ci.yml/badge.svg)](https://github.com/ayagmar/pi-extmgr/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -13,16 +13,34 @@ A better way to manage Pi extensions. Browse, install, enable/disable, and remov
 pi install npm:pi-extmgr
 ```
 
-Then reload Pi with `/reload`.
-
-## What it does
-
-- **Unified view**: See all your local extensions and installed npm/git packages in one list
-- **Toggle extensions**: Enable/disable local extensions with Space/Enter, save with `S`
-- **Package actions**: Update or remove installed packages with `A`
-- **Browse community**: Search and install from npm (`R` to browse)
-- **History tracking**: See what you've changed with `/extensions history`
-- **Smart reload prompt**: After applying extension state changes, extmgr can trigger reload directly from the UI
+Then reload Pi.
+
+## Features
+
+- **Unified manager UI**
+  - Local extensions (`~/.pi/agent/extensions`, `.pi/extensions`) and installed packages in one list
+  - Scope indicators (global/project), status indicators, update badges
+- **Safe staged local extension toggles**
+  - Toggle with `Space/Enter`, apply with `S`
+  - Unsaved-change guard when leaving (save/discard/stay)
+- **Package management**
+  - Install, update, remove from UI and command line
+  - Quick actions (`A`, `u`, `X`) and bulk update (`U`)
+- **Remote discovery and install**
+  - npm search/browse with pagination
+  - Install by source (`npm:`, `git:`, URL, local path)
+  - Supports direct GitHub `.ts` installs and local standalone install mode
+- **Auto-update**
+  - Interactive wizard (`t` in manager, or `/extensions auto-update`)
+  - Persistent schedule restored on startup and session switch
+  - Background checks + status bar updates
+- **Operational visibility**
+  - Session history (`/extensions history`)
+  - Cache controls (`/extensions clear-cache`)
+  - Status line summary (`pkg count • auto-update • known updates`)
+- **Interactive + non-interactive support**
+  - Works in TUI and non-UI modes
+  - Non-interactive commands for list/install/remove/update/auto-update
 
 ## Usage
 
@@ -41,11 +59,12 @@ Open the manager:
 | `S`           | Save changes                                     |
 | `Enter` / `A` | Actions on selected package (update/remove/view) |
 | `u`           | Update selected package directly                 |
-| `X`           | Remove selected package directly                 |
+| `X`           | Remove selected item (package/local extension)   |
 | `i`           | Quick install by source                          |
 | `f`           | Quick search                                     |
 | `U`           | Update all packages                              |
 | `t`           | Auto-update wizard                               |
+| `P` / `M`     | Quick actions palette                            |
 | `R`           | Browse remote packages                           |
 | `?` / `H`     | Help                                             |
 | `Esc`         | Exit                                             |
@@ -53,17 +72,51 @@ Open the manager:
 ### Commands
 
 ```bash
-/extensions                      # Open the manager
-/extensions search <query>       # Search npm
-/extensions install <source>     # Install package
+/extensions                      # Open interactive manager (default)
+/extensions local                # Alias: open interactive manager
+/extensions list                 # List local extensions
+/extensions remote               # Open remote package browser
+/extensions packages             # Alias: remote browser
+/extensions installed            # Installed packages view (legacy alias to unified flow)
+/extensions search <query>       # Search npm packages
+/extensions install <source> [--project|--global]  # Install package
 /extensions remove [source]      # Remove package
+/extensions uninstall [source]   # Alias: remove
 /extensions update [source]      # Update one package (or all when omitted)
-/extensions auto-update [every]  # No arg opens wizard; accepts 1d, 1w, never, etc.
-/extensions history              # View change history
-/extensions stats                # View statistics
+/extensions auto-update [every]  # No arg opens wizard in UI; accepts 1d, 1w, never, etc.
+/extensions history [options]    # View change history (supports filters)
 /extensions clear-cache          # Clear metadata cache
 ```
 
+### Non-interactive mode
+
+When Pi is running without UI, extmgr still supports command-driven workflows:
+
+- `/extensions list`
+- `/extensions installed`
+- `/extensions install <source> [--project|--global]`
+- `/extensions remove <source>`
+- `/extensions update [source]`
+- `/extensions history [options]`
+- `/extensions auto-update <duration>`
+
+Remote browsing/search menus require interactive mode.
+
+History options (works in non-interactive mode too):
+
+- `--limit <n>`
+- `--action <extension_toggle|package_install|package_update|package_remove|cache_clear>`
+- `--success` / `--failed`
+- `--package <query>`
+- `--since <duration>` (e.g. `30m`, `24h`, `7d`, `1mo`)
+- `--global` (non-interactive mode only; reads all persisted sessions)
+
+Examples:
+
+- `/extensions history --failed --limit 50`
+- `/extensions history --action package_update --since 7d`
+- `/extensions history --global --package extmgr --since 24h`
+
 ### Install sources
 
 ```bash
@@ -81,13 +134,9 @@ Open the manager:
 - **Two install modes**:
   - **Managed** (npm): Auto-updates with `pi update`, stored in pi's package cache
   - **Local** (standalone): Copies to `~/.pi/agent/extensions/{package}/`, supports multi-file extensions
-- **Auto-update schedule is persistent**: `/extensions auto-update 1d` stays active across future Pi sessions.
+- **Auto-update schedule is persistent**: `/extensions auto-update 1d` stays active across future Pi sessions and is restored when switching sessions.
 - **Reload is built-in**: When extmgr asks to reload, it calls `ctx.reload()` directly.
-- **Remove requires restart**: After removing a package, you need to fully restart Pi (not just `/reload`) for it to be completely unloaded.
-
-## Keyboard shortcut
-
-Press `Ctrl+Shift+E` anywhere to open the extension manager.
+- **Remove requires restart**: After removing a package, you need to fully restart Pi (not just a reload) for it to be completely unloaded.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-extmgr",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Enhanced UX for managing local Pi extensions and community packages",
   "keywords": [
     "pi-package",
@@ -34,8 +34,8 @@
     "extensions": [
       "./src/index.ts"
     ],
-    "video": "https://github.com/ayagmar/pi-extmgr/releases/download/v0.0.2/Screencast_20260207_013142.mp4",
-    "image": "https://i.imgur.com/7ifGp5x.png"
+    "video": "https://github.com/ayagmar/pi-extmgr/releases/download/demo/demo.mp4",
+    "image": "https://i.imgur.com/bVM7ZcO.png"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*",
@@ -56,6 +56,9 @@
   },
   "author": "ayagmar",
   "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/ayagmar/pi-extmgr.git"

package/src/commands/auto-update.ts

@@ -0,0 +1,80 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import {
+  disableAutoUpdate,
+  enableAutoUpdate,
+  getAutoUpdateStatus,
+  promptAutoUpdateWizard,
+} from "../utils/auto-update.js";
+import { notify } from "../utils/notify.js";
+import { parseDuration } from "../utils/settings.js";
+import { updateExtmgrStatus } from "../utils/status.js";
+
+function onUpdateAvailable(
+  ctx: ExtensionCommandContext | ExtensionContext,
+  packages: string[]
+): void {
+  notify(
+    ctx,
+    `Updates available for ${packages.length} package(s): ${packages.join(", ")}`,
+    "info"
+  );
+}
+
+export async function handleAutoUpdateSubcommand(
+  tokens: string[],
+  ctx: ExtensionCommandContext | ExtensionContext,
+  pi: ExtensionAPI
+): Promise<void> {
+  const trimmed = tokens.join(" ").trim();
+
+  if (!trimmed && ctx.hasUI) {
+    await promptAutoUpdateWizard(pi, ctx, (packages) => onUpdateAvailable(ctx, packages));
+    void updateExtmgrStatus(ctx, pi);
+    return;
+  }
+
+  const duration = parseDuration(trimmed);
+
+  if (!duration) {
+    const status = getAutoUpdateStatus(ctx);
+    notify(ctx, `Auto-update: ${status}`, "info");
+
+    const usage = [
+      "Usage: /extensions auto-update <duration>",
+      "",
+      "Duration examples:",
+      "  never   - Disable auto-updates",
+      "  1h      - Check every hour",
+      "  2h      - Check every 2 hours",
+      "  1d      - Check daily",
+      "  3d      - Check every 3 days",
+      "  1w      - Check weekly",
+      "  2w      - Check every 2 weeks",
+      "  1m      - Check monthly",
+      "  daily   - Check daily (alias)",
+      "  weekly  - Check weekly (alias)",
+    ];
+    notify(ctx, usage.join("\n"), "info");
+    return;
+  }
+
+  if (duration.ms === 0) {
+    disableAutoUpdate(pi, ctx);
+  } else {
+    enableAutoUpdate(pi, ctx, duration.ms, duration.display, (packages) =>
+      onUpdateAvailable(ctx, packages)
+    );
+  }
+
+  void updateExtmgrStatus(ctx, pi);
+}
+
+export function createAutoUpdateNotificationHandler(
+  ctx: ExtensionCommandContext | ExtensionContext
+): (packages: string[]) => void {
+  return (packages) => onUpdateAvailable(ctx, packages);
+}

package/src/commands/cache.ts

@@ -0,0 +1,22 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { clearCache } from "../utils/cache.js";
+import { logCacheClear } from "../utils/history.js";
+import { notify } from "../utils/notify.js";
+import { updateExtmgrStatus } from "../utils/status.js";
+
+export async function clearMetadataCacheCommand(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI
+): Promise<void> {
+  try {
+    await clearCache();
+    logCacheClear(pi, true);
+    notify(ctx, "Metadata cache cleared.", "info");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logCacheClear(pi, false, message);
+    notify(ctx, `Failed to clear metadata cache: ${message}`, "error");
+  }
+
+  void updateExtmgrStatus(ctx, pi);
+}

package/src/commands/history.ts

@@ -0,0 +1,264 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import {
+  formatChangeEntry,
+  queryGlobalHistory,
+  querySessionChanges,
+  type ChangeAction,
+  type HistoryFilters,
+} from "../utils/history.js";
+import { notify } from "../utils/notify.js";
+import { formatListOutput } from "../utils/ui-helpers.js";
+
+const HISTORY_ACTIONS: ChangeAction[] = [
+  "extension_toggle",
+  "package_install",
+  "package_update",
+  "package_remove",
+  "cache_clear",
+];
+
+interface ParsedHistoryArgs {
+  filters: HistoryFilters;
+  global: boolean;
+  showHelp: boolean;
+  errors: string[];
+}
+
+interface HistoryParseState {
+  filters: HistoryFilters;
+  global: boolean;
+  showHelp: boolean;
+  errors: string[];
+}
+
+type HistoryOptionHandler = (tokens: string[], index: number, state: HistoryParseState) => number;
+
+const HISTORY_ACTION_SET = new Set<ChangeAction>(HISTORY_ACTIONS);
+
+function parseHistorySinceDuration(input: string): number | undefined {
+  const normalized = input.toLowerCase().trim();
+  const match = normalized.match(
+    /^(\d+)\s*(m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days|w|wk|wks|week|weeks|mo|mos|month|months)$/
+  );
+  if (!match) return undefined;
+
+  const value = Number.parseInt(match[1] ?? "", 10);
+  if (!Number.isFinite(value) || value <= 0) return undefined;
+
+  const unit = match[2] ?? "";
+  if (unit.startsWith("m") && !unit.startsWith("mo")) {
+    return value * 60 * 1000;
+  }
+  if (unit.startsWith("h")) {
+    return value * 60 * 60 * 1000;
+  }
+  if (unit.startsWith("d")) {
+    return value * 24 * 60 * 60 * 1000;
+  }
+  if (unit.startsWith("w")) {
+    return value * 7 * 24 * 60 * 60 * 1000;
+  }
+  if (unit.startsWith("mo")) {
+    return value * 30 * 24 * 60 * 60 * 1000;
+  }
+
+  return undefined;
+}
+
+const HISTORY_OPTION_HANDLERS: Record<string, HistoryOptionHandler> = {
+  "--help": (_tokens, _index, state) => {
+    state.showHelp = true;
+    return 0;
+  },
+  "-h": (_tokens, _index, state) => {
+    state.showHelp = true;
+    return 0;
+  },
+  "--global": (_tokens, _index, state) => {
+    state.global = true;
+    return 0;
+  },
+  "--limit": (tokens, index, state) => {
+    const value = tokens[index + 1];
+    if (!value) {
+      state.errors.push("--limit requires a number");
+      return 0;
+    }
+
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      state.errors.push(`Invalid --limit value: ${value}`);
+    } else {
+      state.filters.limit = parsed;
+    }
+
+    return 1;
+  },
+  "--action": (tokens, index, state) => {
+    const value = tokens[index + 1] as ChangeAction | undefined;
+    if (!value) {
+      state.errors.push("--action requires a value");
+      return 0;
+    }
+
+    if (!HISTORY_ACTION_SET.has(value)) {
+      state.errors.push(`Invalid --action value: ${value}`);
+    } else {
+      state.filters.action = value;
+    }
+
+    return 1;
+  },
+  "--failed": (_tokens, _index, state) => {
+    if (state.filters.success === true) {
+      state.errors.push("Use either --success or --failed, not both");
+    }
+    state.filters.success = false;
+    return 0;
+  },
+  "--success": (_tokens, _index, state) => {
+    if (state.filters.success === false) {
+      state.errors.push("Use either --success or --failed, not both");
+    }
+    state.filters.success = true;
+    return 0;
+  },
+  "--package": (tokens, index, state) => {
+    const value = tokens[index + 1];
+    if (!value) {
+      state.errors.push("--package requires a value");
+      return 0;
+    }
+
+    state.filters.packageQuery = value;
+    return 1;
+  },
+  "--since": (tokens, index, state) => {
+    const value = tokens[index + 1];
+    if (!value) {
+      state.errors.push("--since requires a duration (e.g. 30m, 7d, 24h)");
+      return 0;
+    }
+
+    const ms = parseHistorySinceDuration(value);
+    if (!ms) {
+      state.errors.push(`Invalid --since duration: ${value}`);
+    } else {
+      state.filters.sinceTimestamp = Date.now() - ms;
+    }
+
+    return 1;
+  },
+};
+
+function parseHistoryArgs(tokens: string[]): ParsedHistoryArgs {
+  const state: HistoryParseState = {
+    filters: { limit: 20 },
+    global: false,
+    showHelp: false,
+    errors: [],
+  };
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i] ?? "";
+    const handler = HISTORY_OPTION_HANDLERS[token];
+
+    if (!handler) {
+      state.errors.push(`Unknown history option: ${token}`);
+      continue;
+    }
+
+    const consumed = handler(tokens, i, state);
+    i += consumed;
+  }
+
+  return {
+    filters: state.filters,
+    global: state.global,
+    showHelp: state.showHelp,
+    errors: state.errors,
+  };
+}
+
+function showHistoryHelp(ctx: ExtensionCommandContext): void {
+  const lines = [
+    "Usage: /extensions history [options]",
+    "",
+    "Options:",
+    "  --limit <n>      Maximum entries to show (default: 20)",
+    "  --action <type>  Filter by action",
+    "                   extension_toggle | package_install | package_update | package_remove | cache_clear",
+    "  --success        Show only successful entries",
+    "  --failed         Show only failed entries",
+    "  --package <q>    Filter by package/source/extension id",
+    "  --since <d>      Show only entries newer than duration (e.g. 30m, 24h, 7d, 1mo)",
+    "  --global         Read all persisted sessions (non-interactive mode only)",
+    "",
+    "Examples:",
+    "  /extensions history --failed --limit 50",
+    "  /extensions history --action package_update --since 7d",
+    "  /extensions history --package extmgr --since 30m",
+    "  /extensions history --global --failed --since 14d",
+  ];
+
+  notify(ctx, lines.join("\n"), "info");
+}
+
+function formatSessionSuffix(sessionFile: string): string {
+  const marker = "/.pi/agent/sessions/";
+  const normalized = sessionFile.replace(/\\/g, "/");
+  const index = normalized.indexOf(marker);
+  if (index >= 0) {
+    return normalized.slice(index + marker.length);
+  }
+  return sessionFile;
+}
+
+export async function handleHistorySubcommand(
+  ctx: ExtensionCommandContext,
+  _pi: ExtensionAPI,
+  tokens: string[],
+  allowGlobal: boolean
+): Promise<void> {
+  const parsed = parseHistoryArgs(tokens);
+
+  if (parsed.showHelp) {
+    showHistoryHelp(ctx);
+    return;
+  }
+
+  if (parsed.errors.length > 0) {
+    notify(ctx, parsed.errors.join("\n"), "warning");
+    showHistoryHelp(ctx);
+    return;
+  }
+
+  if (parsed.global && !allowGlobal) {
+    notify(ctx, "--global is only available in non-interactive mode.", "warning");
+    return;
+  }
+
+  if (parsed.global) {
+    const changes = await queryGlobalHistory(parsed.filters);
+    if (changes.length === 0) {
+      notify(ctx, "No matching extension changes found across persisted sessions.", "info");
+      return;
+    }
+
+    const lines = changes.map(
+      ({ change, sessionFile }) =>
+        `${formatChangeEntry(change)}  [${formatSessionSuffix(sessionFile)}]`
+    );
+    formatListOutput(ctx, `Extension Change History (global, recent ${changes.length})`, lines);
+    return;
+  }
+
+  const changes = querySessionChanges(ctx, parsed.filters);
+  if (changes.length === 0) {
+    notify(ctx, "No matching extension changes found in this session.", "info");
+    return;
+  }
+
+  const lines = changes.map(formatChangeEntry);
+  formatListOutput(ctx, `Extension Change History (recent ${changes.length})`, lines);
+}

package/src/commands/install.ts

@@ -0,0 +1,83 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { installPackage, type InstallScope } from "../packages/install.js";
+import { notify } from "../utils/notify.js";
+
+export const INSTALL_USAGE = "Usage: /extensions install <source> [--project|--global]";
+
+interface ParsedInstallArgs {
+  source: string;
+  scope?: InstallScope;
+  errors: string[];
+}
+
+interface InstallParseState {
+  sourceParts: string[];
+  scope?: InstallScope;
+  errors: string[];
+}
+
+type InstallOptionHandler = (state: InstallParseState) => void;
+
+const INSTALL_OPTION_HANDLERS: Record<string, InstallOptionHandler> = {
+  "--project": (state) => {
+    if (state.scope === "global") {
+      state.errors.push("Use either --project or --global, not both");
+    }
+    state.scope = "project";
+  },
+  "-l": (state) => {
+    if (state.scope === "global") {
+      state.errors.push("Use either --project or --global, not both");
+    }
+    state.scope = "project";
+  },
+  "--global": (state) => {
+    if (state.scope === "project") {
+      state.errors.push("Use either --project or --global, not both");
+    }
+    state.scope = "global";
+  },
+};
+
+function parseInstallArgs(tokens: string[]): ParsedInstallArgs {
+  const state: InstallParseState = {
+    sourceParts: [],
+    errors: [],
+  };
+
+  for (const token of tokens) {
+    const optionHandler = INSTALL_OPTION_HANDLERS[token];
+    if (optionHandler) {
+      optionHandler(state);
+    } else {
+      state.sourceParts.push(token);
+    }
+  }
+
+  return {
+    source: state.sourceParts.join(" ").trim(),
+    ...(state.scope ? { scope: state.scope } : {}),
+    errors: state.errors,
+  };
+}
+
+export async function handleInstallSubcommand(
+  tokens: string[],
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI
+): Promise<void> {
+  const parsed = parseInstallArgs(tokens);
+
+  if (parsed.errors.length > 0) {
+    notify(ctx, parsed.errors.join("\n"), "warning");
+    notify(ctx, INSTALL_USAGE, "info");
+    return;
+  }
+
+  if (!parsed.source) {
+    notify(ctx, INSTALL_USAGE, "info");
+    return;
+  }
+
+  await installPackage(parsed.source, ctx, pi, parsed.scope ? { scope: parsed.scope } : undefined);
+}