pi-extmgr 0.1.22 → 0.1.24

package/src/utils/command.ts

@@ -3,7 +3,83 @@
  */
 
 export function tokenizeArgs(input: string): string[] {
-  return input.trim().split(/\s+/).filter(Boolean);
+  const tokens: string[] = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let tokenStarted = false;
+
+  const pushCurrent = () => {
+    if (tokenStarted) {
+      tokens.push(current);
+      current = "";
+      tokenStarted = false;
+    }
+  };
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i]!;
+    const next = input[i + 1];
+
+    if (inSingleQuote) {
+      if (char === "'") {
+        inSingleQuote = false;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (inDoubleQuote) {
+      if (char === '"') {
+        inDoubleQuote = false;
+        continue;
+      }
+
+      if (char === "\\" && next === '"') {
+        current += next;
+        i++;
+        continue;
+      }
+
+      current += char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      pushCurrent();
+      continue;
+    }
+
+    if (char === "'") {
+      inSingleQuote = true;
+      tokenStarted = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inDoubleQuote = true;
+      tokenStarted = true;
+      continue;
+    }
+
+    if (char === "\\" && (next === '"' || next === "'" || /\s/.test(next ?? ""))) {
+      tokenStarted = true;
+      if (next) {
+        current += next;
+        i++;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    tokenStarted = true;
+    current += char;
+  }
+
+  pushCurrent();
+  return tokens;
 }
 
 export function splitCommandArgs(input: string): { subcommand: string; args: string[] } {

package/src/utils/format.ts

@@ -59,6 +59,9 @@ export function formatBytes(bytes: number): string {
 
 const GIT_PATTERNS = {
   gitPrefix: /^git:/,
+  gitPlusHttpPrefix: /^git\+https?:\/\//,
+  gitPlusSshPrefix: /^git\+ssh:\/\//,
+  gitPlusGitPrefix: /^git\+git:\/\//,
   httpPrefix: /^https?:\/\//,
   sshPrefix: /^ssh:\/\//,
   gitProtoPrefix: /^git:\/\//,
@@ -78,6 +81,9 @@ const LOCAL_PATH_PATTERNS = {
 function isGitLikeSource(source: string): boolean {
   return (
     GIT_PATTERNS.gitPrefix.test(source) ||
+    GIT_PATTERNS.gitPlusHttpPrefix.test(source) ||
+    GIT_PATTERNS.gitPlusSshPrefix.test(source) ||
+    GIT_PATTERNS.gitPlusGitPrefix.test(source) ||
     GIT_PATTERNS.httpPrefix.test(source) ||
     GIT_PATTERNS.sshPrefix.test(source) ||
     GIT_PATTERNS.gitProtoPrefix.test(source) ||
@@ -97,22 +103,36 @@ function isLocalPathSource(source: string): boolean {
   );
 }
 
+function unwrapQuotedSource(source: string): string {
+  const trimmed = source.trim();
+  if (trimmed.length < 2) return trimmed;
+
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+
+  return trimmed;
+}
+
 export function isPackageSource(str: string): boolean {
-  const source = str.trim();
+  const source = unwrapQuotedSource(str);
   if (!source) return false;
 
   return source.startsWith("npm:") || isGitLikeSource(source) || isLocalPathSource(source);
 }
 
 export function normalizePackageSource(source: string): string {
-  const trimmed = source.trim();
+  const trimmed = unwrapQuotedSource(source);
   if (!trimmed) return trimmed;
 
   if (GIT_PATTERNS.gitSsh.test(trimmed)) {
     return `git:${trimmed}`;
   }
 
-  if (isPackageSource(trimmed)) {
+  if (trimmed.startsWith("npm:") || isGitLikeSource(trimmed) || isLocalPathSource(trimmed)) {
     return trimmed;
   }
 

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/npm-exec.ts

@@ -0,0 +1,47 @@
+import path from "node:path";
+import { execPath, platform } from "node:process";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+interface NpmCommandResolutionOptions {
+  platform?: NodeJS.Platform;
+  nodeExecPath?: string;
+}
+
+interface NpmExecOptions {
+  timeout: number;
+}
+
+function getNpmCliPath(nodeExecPath: string, runtimePlatform: NodeJS.Platform): string {
+  const pathImpl = runtimePlatform === "win32" ? path.win32 : path;
+  return pathImpl.join(pathImpl.dirname(nodeExecPath), "node_modules", "npm", "bin", "npm-cli.js");
+}
+
+export function resolveNpmCommand(
+  npmArgs: string[],
+  options?: NpmCommandResolutionOptions
+): { command: string; args: string[] } {
+  const runtimePlatform = options?.platform ?? platform;
+
+  if (runtimePlatform === "win32") {
+    const nodeBinary = options?.nodeExecPath ?? execPath;
+    return {
+      command: nodeBinary,
+      args: [getNpmCliPath(nodeBinary, runtimePlatform), ...npmArgs],
+    };
+  }
+
+  return { command: "npm", args: npmArgs };
+}
+
+export async function execNpm(
+  pi: ExtensionAPI,
+  npmArgs: string[],
+  ctx: { cwd: string },
+  options: NpmExecOptions
+): Promise<{ code: number; stdout: string; stderr: string; killed: boolean }> {
+  const resolved = resolveNpmCommand(npmArgs);
+  return pi.exec(resolved.command, resolved.args, {
+    timeout: options.timeout,
+    cwd: ctx.cwd,
+  });
+}

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";
 
@@ -18,6 +19,10 @@ export function getPackageSourceKind(source: string): PackageSourceKind {
 
   if (
     normalized.startsWith("git:") ||
+    normalized.startsWith("git+http://") ||
+    normalized.startsWith("git+https://") ||
+    normalized.startsWith("git+ssh://") ||
+    normalized.startsWith("git+git://") ||
     normalized.startsWith("http://") ||
     normalized.startsWith("https://") ||
     normalized.startsWith("ssh://") ||
@@ -43,6 +48,44 @@ export function getPackageSourceKind(source: string): PackageSourceKind {
   return "unknown";
 }
 
+export function normalizeLocalSourceIdentity(source: string): string {
+  const normalized = source.replace(/\\/g, "/");
+  const looksWindowsPath =
+    /^[a-zA-Z]:\//.test(normalized) || normalized.startsWith("//") || source.includes("\\");
+
+  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);