pi-extmgr 0.1.23 → 0.1.24

package/src/utils/auto-update.ts

@@ -19,6 +19,8 @@ import {
 } from "./settings.js";
 import { parseNpmSource } from "./format.js";
 import { execNpm } from "./npm-exec.js";
+import { normalizePackageIdentity } from "./package-source.js";
+import { logAutoUpdateConfig } from "./history.js";
 import { TIMEOUTS } from "../constants.js";
 
 import { startTimer, stopTimer, isTimerRunning } from "./timer.js";
@@ -26,6 +28,10 @@ import { startTimer, stopTimer, isTimerRunning } from "./timer.js";
 // Context provider for safe session handling
 export type ContextProvider = () => (ExtensionCommandContext | ExtensionContext) | undefined;
 
+function getUpdateIdentity(pkg: InstalledPackage): string {
+  return normalizePackageIdentity(pkg.source);
+}
+
 /**
  * Start auto-update background checker
  * Uses a context provider to avoid stale context issues when sessions switch
@@ -48,27 +54,23 @@ export function startAutoUpdateTimer(
   const interval = getScheduleInterval(config);
   if (!interval) return;
 
-  // Run an initial check immediately.
-  const initialCtx = getCtx();
-  if (initialCtx) {
-    void checkForUpdates(pi, initialCtx, onUpdateAvailable);
-  }
-
-  // Set up recurring checks
-  startTimer(interval, () => {
-    const checkCtx = getCtx();
-    if (!checkCtx) {
-      stopAutoUpdateTimer();
-      return;
-    }
-    void checkForUpdates(pi, checkCtx, onUpdateAvailable);
-  });
-
-  // Persist that timer is running
-  saveAutoUpdateConfig(pi, {
-    ...config,
-    nextCheck: calculateNextCheck(config.intervalMs),
-  });
+  const now = Date.now();
+  const nextCheck = config.nextCheck;
+  const initialDelayMs =
+    typeof nextCheck === "number" && nextCheck > now ? Math.max(0, nextCheck - now) : 0;
+
+  startTimer(
+    interval,
+    () => {
+      const checkCtx = getCtx();
+      if (!checkCtx) {
+        stopAutoUpdateTimer();
+        return;
+      }
+      void checkForUpdates(pi, checkCtx, onUpdateAvailable);
+    },
+    { initialDelayMs }
+  );
 }
 
 /**
@@ -98,28 +100,30 @@ export async function checkForUpdates(
   const npmPackages = packages.filter((p) => p.source.startsWith("npm:"));
 
   const updatesAvailable: string[] = [];
+  const updatedPackageNames: string[] = [];
 
   for (const pkg of npmPackages) {
     const hasUpdate = await checkPackageUpdate(pkg, ctx, pi);
     if (hasUpdate) {
-      updatesAvailable.push(pkg.name);
+      updatesAvailable.push(getUpdateIdentity(pkg));
+      updatedPackageNames.push(pkg.name);
     }
   }
 
-  // Update last check time
+  const checkedAt = Date.now();
   const config = getAutoUpdateConfig(ctx);
   saveAutoUpdateConfig(pi, {
     ...config,
-    lastCheck: Date.now(),
+    lastCheck: checkedAt,
     nextCheck: calculateNextCheck(config.intervalMs),
     updatesAvailable,
   });
 
-  if (updatesAvailable.length > 0 && onUpdateAvailable) {
-    onUpdateAvailable(updatesAvailable);
+  if (updatedPackageNames.length > 0 && onUpdateAvailable) {
+    onUpdateAvailable(updatedPackageNames);
   }
 
-  return updatesAvailable;
+  return updatedPackageNames;
 }
 
 /**
@@ -168,7 +172,7 @@ export function getAutoUpdateStatus(ctx: ExtensionCommandContext | ExtensionCont
 }
 
 /**
- * Return package names currently known to have updates available
+ * Return normalized package identities currently known to have updates available
  * (from the latest background check).
  */
 export function getKnownUpdates(ctx: ExtensionCommandContext | ExtensionContext): Set<string> {
@@ -251,12 +255,12 @@ export function enableAutoUpdate(
     intervalMs,
     enabled: true,
     displayText,
-    lastCheck: Date.now(),
     nextCheck: calculateNextCheck(intervalMs),
     updatesAvailable: [],
   };
 
   saveAutoUpdateConfig(pi, config);
+  logAutoUpdateConfig(pi, `set to ${displayText}`, true);
 
   const getCtx: ContextProvider = () => ctx;
 
@@ -280,6 +284,7 @@ export function disableAutoUpdate(
     displayText: "off",
     updatesAvailable: [],
   });
+  logAutoUpdateConfig(pi, "disabled", true);
 
   notify(ctx, "Auto-update disabled", "info");
 }

package/src/utils/history.ts

@@ -9,10 +9,12 @@ import { join } from "node:path";
 
 export type ChangeAction =
   | "extension_toggle"
+  | "extension_delete"
   | "package_install"
   | "package_update"
   | "package_remove"
-  | "cache_clear";
+  | "cache_clear"
+  | "auto_update_config";
 
 export interface ExtensionChangeEntry {
   action: ChangeAction;
@@ -26,6 +28,7 @@ export interface ExtensionChangeEntry {
   packageName?: string | undefined;
   version?: string | undefined;
   scope?: "global" | "project" | undefined;
+  detail?: string | undefined;
   // Result
   success: boolean;
   error?: string | undefined;
@@ -80,6 +83,34 @@ export function logExtensionToggle(
   });
 }
 
+export function logExtensionDelete(
+  pi: ExtensionAPI,
+  extensionId: string,
+  success: boolean,
+  error?: string
+): void {
+  logChange(pi, {
+    action: "extension_delete",
+    extensionId,
+    success,
+    error,
+  });
+}
+
+export function logAutoUpdateConfig(
+  pi: ExtensionAPI,
+  detail: string,
+  success: boolean,
+  error?: string
+): void {
+  logChange(pi, {
+    action: "auto_update_config",
+    detail,
+    success,
+    error,
+  });
+}
+
 /**
  * Log package installation
  */
@@ -180,10 +211,12 @@ function matchesHistoryFilters(change: ExtensionChangeEntry, filters: HistoryFil
     const packageName = change.packageName?.toLowerCase() ?? "";
     const packageSource = change.packageSource?.toLowerCase() ?? "";
     const extensionId = change.extensionId?.toLowerCase() ?? "";
+    const detail = change.detail?.toLowerCase() ?? "";
     if (
       !packageName.includes(packageQuery) &&
       !packageSource.includes(packageQuery) &&
-      !extensionId.includes(packageQuery)
+      !extensionId.includes(packageQuery) &&
+      !detail.includes(packageQuery)
     ) {
       return false;
     }
@@ -330,6 +363,9 @@ export function formatChangeEntry(entry: ExtensionChangeEntry): string {
     case "extension_toggle":
       return `[${time}] ${icon} ${entry.extensionId}: ${entry.fromState} → ${entry.toState}`;
 
+    case "extension_delete":
+      return `[${time}] ${icon} Deleted ${entry.extensionId ?? "extension"}`;
+
     case "package_install":
       return `[${time}] ${icon} Installed ${packageLabel}${entry.version ? `@${entry.version}` : ""}${sourceSuffix}`;
 
@@ -342,6 +378,9 @@ export function formatChangeEntry(entry: ExtensionChangeEntry): string {
     case "cache_clear":
       return `[${time}] ${icon} Cache cleared`;
 
+    case "auto_update_config":
+      return `[${time}] ${icon} Auto-update ${entry.detail ?? "configuration changed"}`;
+
     default:
       return `[${time}] ${icon} Unknown action`;
   }

package/src/utils/mode.ts

@@ -1,12 +1,25 @@
 /**
- * UI vs non-UI mode abstractions
+ * UI capability helpers
  */
-import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { notify } from "./notify.js";
 
-/**
- * Check if operation can proceed in current mode
- */
+type AnyContext = ExtensionCommandContext | ExtensionContext;
+
+export type UICapability = "none" | "dialog" | "custom";
+
+export function getUICapability(ctx: AnyContext): UICapability {
+  if (!ctx.hasUI) {
+    return "none";
+  }
+
+  return typeof ctx.ui?.custom === "function" ? "custom" : "dialog";
+}
+
+export function hasCustomUI(ctx: AnyContext): boolean {
+  return getUICapability(ctx) === "custom";
+}
+
 export function requireUI(ctx: ExtensionCommandContext, featureName: string): boolean {
   if (!ctx.hasUI) {
     notify(
@@ -19,6 +32,44 @@ export function requireUI(ctx: ExtensionCommandContext, featureName: string): bo
   return true;
 }
 
+export function requireCustomUI(
+  ctx: AnyContext,
+  featureName: string,
+  fallbackMessage?: string
+): boolean {
+  if (hasCustomUI(ctx)) {
+    return true;
+  }
+
+  const suffix = fallbackMessage ? ` ${fallbackMessage}` : "";
+  if (ctx.hasUI) {
+    notify(ctx, `${featureName} requires the full interactive TUI.${suffix}`, "warning");
+  } else {
+    notify(ctx, `${featureName} requires interactive mode.${suffix}`, "warning");
+  }
+  return false;
+}
+
+export async function runCustomUI<T>(
+  ctx: AnyContext,
+  featureName: string,
+  open: () => Promise<T | undefined>,
+  fallbackMessage?: string
+): Promise<T | undefined> {
+  if (!requireCustomUI(ctx, featureName, fallbackMessage)) {
+    return undefined;
+  }
+
+  const result = await open();
+  if (result !== undefined) {
+    return result;
+  }
+
+  const suffix = fallbackMessage ? ` ${fallbackMessage}` : "";
+  notify(ctx, `${featureName} requires the full interactive TUI.${suffix}`, "warning");
+  return undefined;
+}
+
 /**
  * Execute operation with automatic error handling
  */

package/src/utils/package-source.ts

@@ -1,6 +1,7 @@
 /**
  * Package source parsing helpers shared across discovery/management flows.
  */
+import { parseNpmSource } from "./format.js";
 
 export type PackageSourceKind = "npm" | "git" | "local" | "unknown";
 
@@ -55,6 +56,36 @@ export function normalizeLocalSourceIdentity(source: string): string {
   return looksWindowsPath ? normalized.toLowerCase() : normalized;
 }
 
+export function stripGitSourcePrefix(source: string): string {
+  const withoutGitPlus = source.startsWith("git+") ? source.slice(4) : source;
+  return withoutGitPlus.startsWith("git:") ? withoutGitPlus.slice(4) : withoutGitPlus;
+}
+
+export function normalizePackageIdentity(
+  source: string,
+  options?: { resolvedPath?: string }
+): string {
+  const normalized = sanitizeSource(source);
+  const kind = getPackageSourceKind(normalized);
+
+  if (kind === "npm") {
+    const npm = parseNpmSource(normalized);
+    return `npm:${(npm?.name ?? normalized).toLowerCase()}`;
+  }
+
+  if (kind === "git") {
+    const gitSpec = stripGitSourcePrefix(normalized);
+    const { repo } = splitGitRepoAndRef(gitSpec);
+    return `git:${repo.replace(/\\/g, "/").toLowerCase()}`;
+  }
+
+  if (kind === "local") {
+    return `local:${normalizeLocalSourceIdentity(options?.resolvedPath ?? normalized)}`;
+  }
+
+  return `raw:${normalized.replace(/\\/g, "/").toLowerCase()}`;
+}
+
 export function splitGitRepoAndRef(gitSpec: string): { repo: string; ref?: string | undefined } {
   const lastAt = gitSpec.lastIndexOf("@");
   if (lastAt <= 0) {

package/src/utils/settings-list.ts

@@ -0,0 +1,12 @@
+interface SelectableListLike {
+  selectedIndex?: number;
+}
+
+export function getSettingsListSelectedIndex(settingsList: unknown): number | undefined {
+  if (!settingsList || typeof settingsList !== "object") {
+    return undefined;
+  }
+
+  const selectable = settingsList as SelectableListLike;
+  return Number.isInteger(selectable.selectedIndex) ? selectable.selectedIndex : undefined;
+}

package/src/utils/settings.ts

@@ -11,6 +11,7 @@ import { readFile, writeFile, mkdir, rename, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { fileExists } from "./fs.js";
+import { normalizePackageIdentity } from "./package-source.js";
 
 export interface AutoUpdateConfig {
   intervalMs: number;
@@ -49,6 +50,20 @@ function sanitizeStringArray(value: unknown): string[] | undefined {
   return sanitized.length > 0 ? sanitized : undefined;
 }
 
+function isUpdateIdentity(value: string): boolean {
+  return /^(npm|git|local|raw):/i.test(value);
+}
+
+function sanitizeUpdateIdentities(value: unknown): string[] | undefined {
+  const updates = sanitizeStringArray(value);
+  if (!updates) return undefined;
+
+  const sanitized = updates
+    .filter(isUpdateIdentity)
+    .map((entry) => normalizePackageIdentity(entry));
+  return sanitized.length > 0 ? sanitized : undefined;
+}
+
 function sanitizeAutoUpdateConfig(input: unknown): AutoUpdateConfig {
   if (!isRecord(input)) {
     return { ...DEFAULT_CONFIG };
@@ -85,7 +100,7 @@ function sanitizeAutoUpdateConfig(input: unknown): AutoUpdateConfig {
     config.nextCheck = input.nextCheck;
   }
 
-  const updates = sanitizeStringArray(input.updatesAvailable);
+  const updates = sanitizeUpdateIdentities(input.updatesAvailable);
   if (updates) {
     config.updatesAvailable = updates;
   }
@@ -263,15 +278,28 @@ export function saveAutoUpdateConfig(pi: ExtensionAPI, config: Partial<AutoUpdat
  */
 export function clearUpdatesAvailable(
   pi: ExtensionAPI,
-  ctx: ExtensionCommandContext | ExtensionContext
+  ctx: ExtensionCommandContext | ExtensionContext,
+  identities?: Iterable<string>
 ): void {
   const config = getAutoUpdateConfig(ctx);
-  if (config.updatesAvailable && config.updatesAvailable.length > 0) {
-    saveAutoUpdateConfig(pi, {
-      ...config,
-      updatesAvailable: [],
-    });
+  const currentUpdates = config.updatesAvailable ?? [];
+  if (currentUpdates.length === 0) {
+    return;
+  }
+
+  const clearedIdentities = identities ? new Set(identities) : undefined;
+  const updatesAvailable = clearedIdentities
+    ? currentUpdates.filter((identity) => !clearedIdentities.has(identity))
+    : [];
+
+  if (updatesAvailable.length === currentUpdates.length) {
+    return;
   }
+
+  saveAutoUpdateConfig(pi, {
+    ...config,
+    updatesAvailable,
+  });
 }
 
 /**

package/src/utils/status.ts

@@ -8,14 +8,22 @@ import type {
 } from "@mariozechner/pi-coding-agent";
 import { getInstalledPackages } from "../packages/discovery.js";
 import { getAutoUpdateStatus } from "./auto-update.js";
+import { normalizePackageIdentity } from "./package-source.js";
 import { getAutoUpdateConfigAsync, saveAutoUpdateConfig } from "./settings.js";
 
 function filterStaleUpdates(
   knownUpdates: string[],
   installedPackages: Awaited<ReturnType<typeof getInstalledPackages>>
 ): string[] {
-  const installedNames = new Set(installedPackages.map((p) => p.name));
-  return knownUpdates.filter((name) => installedNames.has(name));
+  const installedIdentities = new Set(
+    installedPackages.map((pkg) =>
+      normalizePackageIdentity(
+        pkg.source,
+        pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : undefined
+      )
+    )
+  );
+  return knownUpdates.filter((identity) => installedIdentities.has(identity));
 }
 
 export async function updateExtmgrStatus(

package/src/utils/timer.ts

@@ -4,33 +4,57 @@
 
 export type TimerCallback = () => void;
 
-let timerId: ReturnType<typeof setInterval> | null = null;
+let intervalId: ReturnType<typeof setInterval> | null = null;
+let timeoutId: ReturnType<typeof setTimeout> | null = null;
 
 /**
  * Start a recurring timer with the given interval and callback.
  * Clears any existing timer first.
  */
-export function startTimer(intervalMs: number, callback: TimerCallback): void {
+export function startTimer(
+  intervalMs: number,
+  callback: TimerCallback,
+  options?: { initialDelayMs?: number }
+): void {
   stopTimer();
 
   if (intervalMs <= 0) return;
 
-  timerId = setInterval(callback, intervalMs);
+  const runAndReschedule = (): void => {
+    intervalId = setInterval(callback, intervalMs);
+    callback();
+  };
+
+  const initialDelayMs = options?.initialDelayMs ?? 0;
+  if (initialDelayMs <= 0) {
+    runAndReschedule();
+    return;
+  }
+
+  timeoutId = setTimeout(() => {
+    timeoutId = null;
+    runAndReschedule();
+  }, initialDelayMs);
 }
 
 /**
  * Stop the current timer if running.
  */
 export function stopTimer(): void {
-  if (!timerId) return;
-
-  clearInterval(timerId);
-  timerId = null;
+  if (timeoutId) {
+    clearTimeout(timeoutId);
+    timeoutId = null;
+  }
+
+  if (intervalId) {
+    clearInterval(intervalId);
+    intervalId = null;
+  }
 }
 
 /**
  * Check if a timer is currently running.
  */
 export function isTimerRunning(): boolean {
-  return timerId !== null;
+  return timeoutId !== null || intervalId !== null;
 }

package/src/utils/ui-helpers.ts

@@ -67,9 +67,10 @@ export function formatListOutput(
   }
 
   const output = items.join("\n");
+  const titledOutput = `${title}:\n${output}`;
 
   if (ctx.hasUI) {
-    ctx.ui.notify(output, "info");
+    ctx.ui.notify(titledOutput, "info");
   } else {
     console.log(`${title}:`);
     console.log(output);