pi-extmgr 0.0.5 → 0.1.1

package/README.md

@@ -27,16 +27,17 @@
 All your extensions in one place:
 
 - **Local extensions**: `● enabled` / `○ disabled` with `[G]` global or `[P]` project scope
-- **Installed packages**: `📦` icon with name@version
+- **Installed packages**: `◆` npm / `◇` git icon with name@version and size info
 - **Visual distinction** between toggle-able locals and action-based packages
 - **Smart deduplication** - packages already managed as local extensions are hidden
+- **Theme adaptive UI** - Works consistently in dark and light themes
 
 ### 🔍 Smart Package Discovery
 
 - **Browse community packages** with pagination (20 per page)
-- **Cached search results** for lightning-fast navigation
+- **Cached search results** - npm metadata cached for 24 hours for fast navigation
 - **Keyword filtering** - automatically shows `pi-package` tagged npm packages
-- **Detailed package info** - view version, author, homepage
+- **Detailed package info** - view version, author, homepage, and install size
 
 ### 📦 Flexible Installation
 
@@ -56,6 +57,15 @@ All your extensions in one place:
 - **Bulk operations** - update all packages at once
 - **Scope indicators**: Global (G) vs Project (P) for all items
 
+### 📊 Extension Change History
+
+Track all your extension management actions:
+
+- **Automatic logging** - Every toggle, install, update, and remove is recorded
+- **Session persistence** - View change history with `/extensions history`
+- **Statistics** - View totals by action type with `/extensions stats`
+- **Error tracking** - Failed operations are logged with error details
+
 ### 🎯 Quality of Life
 
 - **Tab autocomplete** for all subcommands
@@ -63,6 +73,7 @@ All your extensions in one place:
 - **Keyboard shortcut**: `Ctrl+Shift+E` opens extension manager
 - **Non-interactive mode** - works in scripts and CI
 - **Parallel data loading** - local extensions and packages fetched simultaneously
+- **Metadata caching** - npm package info cached for 24 hours for faster browsing
 
 ## 🚀 Installation
 
@@ -145,6 +156,11 @@ Browse and install from npm:
 /extensions install <source>  # Install from npm/git/path
 /extensions remove [source]   # Remove package (interactive if no source)
 /extensions uninstall [source]# Alias for remove
+
+# History & Stats
+/extensions history           # View recent extension changes
+/extensions stats             # View extension manager statistics
+/extensions clear-cache       # Clear metadata cache
 ```
 
 ### Install Sources
@@ -299,6 +315,16 @@ export default function myTheme(pi: ExtensionAPI) {
 
 The extension remains installed but won't load until re-enabled.
 
+### Removing a Package
+
+1. Type `/extensions` to open unified manager
+2. Navigate to the installed package with `↑↓`
+3. Press `A` for actions
+4. Select "Remove package"
+5. Confirm removal
+
+**Important**: Unlike install/update, removing a package requires a **full restart** of pi (not just `/reload`). The extension files are deleted, but the extension remains loaded in memory until you exit and restart pi.
+
 ### Updating All Packages
 
 1. Type `/extensions` to open unified manager
@@ -307,6 +333,32 @@ The extension remains installed but won't load until re-enabled.
 4. Select "Update package"
 5. Or use command: `/extensions install npm:pi-extmgr` then select "[Update all packages]"
 
+### Viewing Change History
+
+See what you've done in the current session:
+
+```
+/extensions history
+```
+
+Output shows recent actions like:
+
+```
+[12:34:56] ✓ global:my-extension: enabled → disabled
+[12:35:10] ✓ Installed pi-some-package@1.2.3
+[12:36:22] ✓ Updated pi-other-package → @2.0.0
+```
+
+### Viewing Statistics
+
+Get a summary of your extension management activity:
+
+```
+/extensions stats
+```
+
+Shows installed package count, total changes, and breakdown by action type.
+
 ## 🐛 Troubleshooting
 
 ### Commands not showing after install
@@ -330,6 +382,15 @@ Check that the file has a `.ts` or `.js` extension and is in one of the discover
 - For git installs, ensure git is available
 - Verify the package has the `pi-package` keyword for browsing
 
+### Commands still work after removing package
+
+This is expected behavior. When you remove a package:
+
+1. The files are deleted from disk
+2. The extension remains loaded in pi's memory
+3. Commands continue to work until you **restart pi**\n
+   A full restart (Ctrl+C or `/quit`) is required to fully unload removed extensions. `/reload` is only sufficient for install/update operations.
+
 ### Back to manager closes everything
 
 Fixed! Pressing "Back to manager" now correctly returns to the unified view instead of closing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-extmgr",
-  "version": "0.0.5",
+  "version": "0.1.1",
   "description": "Enhanced UX for managing local Pi extensions and community packages",
   "keywords": [
     "pi-package",
@@ -9,9 +9,9 @@
     "pi-extension-manager"
   ],
   "type": "module",
-  "main": "./index.ts",
+  "main": "./src/index.ts",
   "files": [
-    "index.ts",
+    "src/",
     "README.md"
   ],
   "scripts": {
@@ -27,7 +27,7 @@
   },
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./src/index.ts"
     ],
     "video": "https://github.com/ayagmar/pi-extmgr/releases/download/v0.0.2/Screencast_20260207_013142.mp4",
     "image": "https://i.imgur.com/nP5rJPC.png"

package/src/constants.ts

@@ -0,0 +1,7 @@
+/**
+ * Constants for pi-extmgr
+ */
+
+export const DISABLED_SUFFIX = ".disabled";
+export const PAGE_SIZE = 20;
+export const CACHE_TTL = 5 * 60 * 1000; // 5 minutes

package/src/extensions/discovery.ts

@@ -0,0 +1,176 @@
+/**
+ * Local extension discovery
+ */
+import { readdir, rename } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { homedir } from "node:os";
+import type { Dirent } from "node:fs";
+import type { ExtensionEntry, Scope, State } from "../types/index.js";
+import { DISABLED_SUFFIX } from "../constants.js";
+import { fileExists, readSummary } from "../utils/fs.js";
+
+interface RootConfig {
+  root: string;
+  scope: Scope;
+  label: string;
+}
+
+export async function discoverExtensions(cwd: string): Promise<ExtensionEntry[]> {
+  const roots: RootConfig[] = [
+    {
+      root: join(homedir(), ".pi", "agent", "extensions"),
+      scope: "global",
+      label: "~/.pi/agent/extensions",
+    },
+    { root: join(cwd, ".pi", "extensions"), scope: "project", label: ".pi/extensions" },
+  ];
+
+  const all: ExtensionEntry[] = [];
+  for (const root of roots) {
+    all.push(...(await discoverInRoot(root.root, root.scope, root.label)));
+  }
+
+  all.sort((a, b) => a.displayName.localeCompare(b.displayName));
+  return dedupeExtensions(all);
+}
+
+async function discoverInRoot(
+  root: string,
+  scope: Scope,
+  label: string
+): Promise<ExtensionEntry[]> {
+  let dirEntries: Dirent[];
+  try {
+    dirEntries = await readdir(root, { withFileTypes: true });
+  } catch (error) {
+    // Silently ignore ENOENT (directory doesn't exist) - this is expected
+    // for project scope when .pi/extensions doesn't exist yet
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return [];
+    }
+    // Log other errors for debugging
+    console.error(`[extensions-manager] Error reading ${root}:`, error);
+    return [];
+  }
+
+  const found: ExtensionEntry[] = [];
+
+  for (const item of dirEntries) {
+    const name = item.name;
+
+    // Skip hidden files and directories (e.g., .temp, .git, etc.)
+    if (name.startsWith(".")) continue;
+
+    if (item.isFile()) {
+      const entry = await parseTopLevelFile(root, label, scope, name);
+      if (entry) found.push(entry);
+      continue;
+    }
+
+    if (item.isDirectory()) {
+      const entry = await parseDirectoryIndex(root, label, scope, name);
+      if (entry) found.push(entry);
+    }
+  }
+
+  return found;
+}
+
+async function parseTopLevelFile(
+  root: string,
+  label: string,
+  scope: Scope,
+  fileName: string
+): Promise<ExtensionEntry | undefined> {
+  const isEnabledTsJs = /\.(ts|js)$/i.test(fileName) && !fileName.endsWith(DISABLED_SUFFIX);
+  const isDisabledTsJs = /\.(ts|js)\.disabled$/i.test(fileName);
+
+  if (!isEnabledTsJs && !isDisabledTsJs) return undefined;
+
+  const currentPath = join(root, fileName);
+  const activePath = isDisabledTsJs ? currentPath.slice(0, -DISABLED_SUFFIX.length) : currentPath;
+  const disabledPath = `${activePath}${DISABLED_SUFFIX}`;
+  const state: State = isDisabledTsJs ? "disabled" : "enabled";
+  const summary = await readSummary(state === "enabled" ? activePath : disabledPath);
+
+  const relativePath = relative(root, activePath).replace(/\.disabled$/i, "");
+
+  return {
+    id: `${scope}:${activePath}`,
+    scope,
+    state,
+    activePath,
+    disabledPath,
+    displayName: `${label}/${relativePath}`,
+    summary,
+  };
+}
+
+async function parseDirectoryIndex(
+  root: string,
+  label: string,
+  scope: Scope,
+  dirName: string
+): Promise<ExtensionEntry | undefined> {
+  const dir = join(root, dirName);
+
+  for (const ext of [".ts", ".js"]) {
+    const activePath = join(dir, `index${ext}`);
+    const disabledPath = `${activePath}${DISABLED_SUFFIX}`;
+
+    if (await fileExists(activePath)) {
+      return {
+        id: `${scope}:${activePath}`,
+        scope,
+        state: "enabled",
+        activePath,
+        disabledPath,
+        displayName: `${label}/${dirName}/index${ext}`,
+        summary: await readSummary(activePath),
+      };
+    }
+
+    if (await fileExists(disabledPath)) {
+      return {
+        id: `${scope}:${activePath}`,
+        scope,
+        state: "disabled",
+        activePath,
+        disabledPath,
+        displayName: `${label}/${dirName}/index${ext}`,
+        summary: await readSummary(disabledPath),
+      };
+    }
+  }
+
+  return undefined;
+}
+
+function dedupeExtensions(entries: ExtensionEntry[]): ExtensionEntry[] {
+  const byId = new Map<string, ExtensionEntry>();
+  for (const entry of entries) {
+    if (!byId.has(entry.id)) {
+      byId.set(entry.id, entry);
+    }
+  }
+  return Array.from(byId.values());
+}
+
+export async function setExtensionState(
+  entry: Pick<ExtensionEntry, "activePath" | "disabledPath">,
+  target: State
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  try {
+    if (!entry.activePath || !entry.disabledPath) {
+      return { ok: false, error: "Missing paths" };
+    }
+    if (target === "enabled") {
+      await rename(entry.disabledPath, entry.activePath);
+    } else {
+      await rename(entry.activePath, entry.disabledPath);
+    }
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}

package/src/index.ts

@@ -0,0 +1,261 @@
+/**
+ * Extensions Manager - Enhanced UI/UX for managing Pi extensions and packages
+ *
+ * Entry point - exports the main extension function
+ */
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { AutocompleteItem } from "@mariozechner/pi-tui";
+import { isPackageSource } from "./utils/format.js";
+import { showInteractive, showListOnly, showInstalledPackagesLegacy } from "./ui/unified.js";
+import { showRemote } from "./ui/remote.js";
+import { showHelp } from "./ui/help.js";
+import { installPackage } from "./packages/install.js";
+import { removePackage, promptRemove, showInstalledPackagesList } from "./packages/management.js";
+import { getInstalledPackages } from "./packages/discovery.js";
+import { getRecentChanges, formatChangeEntry, getChangeStats } from "./utils/history.js";
+import { clearCache } from "./utils/cache.js";
+
+export default function extensionsManager(pi: ExtensionAPI) {
+  pi.registerCommand("extensions", {
+    description: "Manage local extensions and browse/install community packages",
+    getArgumentCompletions: (prefix: string): AutocompleteItem[] | null => {
+      const commands = [
+        { value: "list", description: "List local extensions" },
+        { value: "local", description: "Open interactive manager (default)" },
+        { value: "remote", description: "Browse community packages" },
+        { value: "packages", description: "Browse community packages (alias)" },
+        { value: "installed", description: "List installed packages" },
+        { value: "search", description: "Search npm for packages" },
+        { value: "install", description: "Install a package" },
+        { value: "remove", description: "Remove an installed package" },
+        { value: "uninstall", description: "Remove an installed package (alias)" },
+        { value: "history", description: "View extension change history" },
+        { value: "stats", description: "View extension manager statistics" },
+        { value: "clear-cache", description: "Clear metadata cache" },
+      ];
+
+      const safePrefix = (prefix ?? "").toLowerCase();
+      const filtered = commands.filter(
+        (c) => c.value.startsWith(safePrefix) || c.description.toLowerCase().includes(safePrefix)
+      );
+
+      return filtered.length > 0
+        ? filtered.map((c) => ({ value: c.value, label: `${c.value} - ${c.description}` }))
+        : null;
+    },
+    handler: async (args, ctx) => {
+      // Check if we have UI support
+      if (!ctx.hasUI) {
+        await handleNonInteractive(args, ctx, pi);
+        return;
+      }
+
+      const input = args.trim();
+      const [subcommand, ...rest] = input.split(/\s+/).filter(Boolean);
+      const sub = (subcommand ?? "").toLowerCase();
+
+      switch (sub) {
+        case "":
+        case "local":
+          await showInteractive(ctx, pi);
+          break;
+        case "list":
+          await showListOnly(ctx);
+          break;
+        case "remote":
+        case "packages":
+          await showRemote(rest.join(" "), ctx, pi);
+          break;
+        case "installed":
+          await showInstalledPackagesLegacy(ctx, pi);
+          break;
+        case "search":
+          await showRemote(`search ${rest.join(" ")}`, ctx, pi);
+          break;
+        case "install":
+          if (rest.length > 0) {
+            await installPackage(rest.join(" "), ctx, pi);
+          } else {
+            await showRemote("install", ctx, pi);
+          }
+          break;
+        case "remove":
+        case "uninstall":
+          if (rest.length > 0) {
+            await removePackage(rest.join(" "), ctx, pi);
+          } else {
+            await promptRemove(ctx, pi);
+          }
+          break;
+        case "history":
+          showHistory(ctx, pi);
+          break;
+        case "stats":
+          await showStats(ctx, pi);
+          break;
+        case "clear-cache":
+          await clearMetadataCache(ctx, pi);
+          break;
+        default:
+          // If it looks like a package source, try to install it
+          if (subcommand && isPackageSource(subcommand)) {
+            await installPackage(input, ctx, pi);
+          } else {
+            ctx.ui.notify(
+              `Unknown command: ${subcommand ?? "(empty)"}. Try: local, remote, installed, search, install, remove`,
+              "warning"
+            );
+          }
+      }
+    },
+  });
+
+  // Status bar integration - show installed package count
+  pi.on("session_start", (_event, ctx) => {
+    if (!ctx.hasUI) return;
+
+    // Defer status update to avoid interfering with extension loading lifecycle
+    // This prevents race conditions during reload where commands might not appear
+    setImmediate(() => {
+      void (async () => {
+        try {
+          const packages = await getInstalledPackages(ctx, pi);
+          if (packages.length > 0) {
+            ctx.ui.setStatus(
+              "extmgr",
+              ctx.ui.theme.fg("dim", `${packages.length} pkg${packages.length === 1 ? "" : "s"}`)
+            );
+          }
+        } catch {
+          // Silently ignore status bar errors
+        }
+      })();
+    });
+  });
+}
+
+async function handleNonInteractive(
+  args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI
+): Promise<void> {
+  const input = args.trim();
+  const [subcommand, ...rest] = input.split(/\s+/).filter(Boolean);
+  const sub = (subcommand ?? "").toLowerCase();
+
+  switch (sub) {
+    case "list":
+      await showListOnly(ctx);
+      break;
+    case "installed":
+      await showInstalledPackagesList(ctx, pi);
+      break;
+    case "remote":
+    case "packages":
+      // Non-interactive: just show help
+      console.log("Extensions Manager (non-interactive mode)");
+      console.log("Remote package browsing requires interactive mode.");
+      console.log("");
+      console.log("Available commands:");
+      console.log("  /extensions list      - List local extensions");
+      console.log("  /extensions installed - List installed packages");
+      console.log("  /extensions install <source> - Install a package");
+      console.log("  /extensions remove <source>  - Remove a package");
+      break;
+    case "search":
+      console.log("Search requires interactive mode.");
+      break;
+    case "install":
+      if (rest.length > 0) {
+        await installPackage(rest.join(" "), ctx, pi);
+      } else {
+        console.log("Usage: /extensions install <npm:package|git:url|path>");
+      }
+      break;
+    case "remove":
+    case "uninstall":
+      if (rest.length > 0) {
+        await removePackage(rest.join(" "), ctx, pi);
+      } else {
+        console.log("Usage: /extensions remove <npm:package|git:url|path>");
+      }
+      break;
+    default:
+      // If it looks like a package source, try to install it
+      if (subcommand && isPackageSource(subcommand)) {
+        await installPackage(input, ctx, pi);
+      } else {
+        console.log("Extensions Manager (non-interactive mode)");
+        console.log("");
+        console.log("Commands:");
+        console.log("  /extensions list      - List local extensions");
+        console.log("  /extensions installed - List installed packages");
+        console.log("");
+        console.log("For full functionality, run in interactive mode.");
+      }
+  }
+}
+
+export { showHelp };
+
+function showHistory(ctx: ExtensionCommandContext, _pi: ExtensionAPI): void {
+  const changes = getRecentChanges(ctx, 20);
+
+  if (changes.length === 0) {
+    const msg = "No extension changes recorded in this session.";
+    if (ctx.hasUI) {
+      ctx.ui.notify(msg, "info");
+    } else {
+      console.log(msg);
+    }
+    return;
+  }
+
+  const lines = changes.map(formatChangeEntry);
+  const output = ["Extension Change History (recent 20):", "", ...lines].join("\n");
+
+  if (ctx.hasUI) {
+    ctx.ui.notify(output, "info");
+  } else {
+    console.log(output);
+  }
+}
+
+async function showStats(ctx: ExtensionCommandContext, pi: ExtensionAPI): Promise<void> {
+  const stats = getChangeStats(ctx);
+  const packages = await getInstalledPackages(ctx, pi);
+
+  const lines = [
+    "Extension Manager Statistics",
+    "",
+    `Installed packages: ${packages.length}`,
+    `Session changes: ${stats.total}`,
+    `  - Successful: ${stats.successful}`,
+    `  - Failed: ${stats.failed}`,
+    "",
+    "Changes by type:",
+    `  - Extension toggles: ${stats.byAction.extension_toggle}`,
+    `  - Package installs: ${stats.byAction.package_install}`,
+    `  - Package updates: ${stats.byAction.package_update}`,
+    `  - Package removals: ${stats.byAction.package_remove}`,
+  ];
+
+  const output = lines.join("\n");
+
+  if (ctx.hasUI) {
+    ctx.ui.notify(output, "info");
+  } else {
+    console.log(output);
+  }
+}
+
+async function clearMetadataCache(ctx: ExtensionCommandContext, _pi: ExtensionAPI): Promise<void> {
+  await clearCache();
+
+  const msg = "Metadata cache cleared.";
+  if (ctx.hasUI) {
+    ctx.ui.notify(msg, "info");
+  } else {
+    console.log(msg);
+  }
+}