pi-extmgr 0.1.27 → 0.2.0

package/src/utils/fs.ts

@@ -4,6 +4,10 @@
 import { access, readFile } from "node:fs/promises";
 import { truncate } from "./format.js";
 
+function formatSummary(text: string): string {
+  return truncate(text.replace(/\s+/g, " ").trim(), 80);
+}
+
 export async function fileExists(filePath: string): Promise<boolean> {
   try {
     await access(filePath);
@@ -28,7 +32,7 @@ export async function readSummary(filePath: string): Promise<string> {
     for (const pattern of descriptionPatterns) {
       const match = text.match(pattern);
       const value = match?.[1]?.trim();
-      if (value) return truncate(value, 80);
+      if (value) return formatSummary(value);
     }
 
     // Look for block comments
@@ -45,7 +49,7 @@ export async function readSummary(filePath: string): Promise<string> {
         )
         .filter((s): s is string => Boolean(s));
       const firstLine = lines[0];
-      if (firstLine) return truncate(firstLine, 80);
+      if (firstLine) return formatSummary(firstLine);
     }
 
     // Look for line comments
@@ -55,13 +59,13 @@ export async function readSummary(filePath: string): Promise<string> {
         .split("\n")
         .map((line) => line.replace(/^\s*\/\/\s?/, "").trim())
         .filter(Boolean)[0];
-      if (first) return truncate(first, 80);
+      if (first) return formatSummary(first);
     }
 
     // First non-empty line
     for (const line of text.split("\n")) {
       const clean = line.trim();
-      if (clean.length > 0) return truncate(clean, 80);
+      if (clean.length > 0) return formatSummary(clean);
     }
   } catch {
     // ignore

package/src/utils/history.ts

@@ -2,10 +2,12 @@
  * Extension change history tracking using pi.appendEntry()
  * This persists extension management actions to the session
  */
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+import { type Dirent } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { type ExtensionAPI, type ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 
 export type ChangeAction =
   | "extension_toggle"
@@ -278,7 +280,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 async function walkSessionFiles(dir: string): Promise<string[]> {
   const result: string[] = [];
 
-  let entries;
+  let entries: Dirent<string>[];
   try {
     entries = await readdir(dir, { withFileTypes: true, encoding: "utf8" });
   } catch {
@@ -297,6 +299,41 @@ async function walkSessionFiles(dir: string): Promise<string[]> {
   return result;
 }
 
+function pushGlobalHistoryEntry(
+  entries: GlobalHistoryEntry[],
+  nextEntry: GlobalHistoryEntry,
+  limit: number | undefined
+): void {
+  if (!limit || limit <= 0) {
+    entries.push(nextEntry);
+    return;
+  }
+
+  if (entries.length < limit) {
+    entries.push(nextEntry);
+    return;
+  }
+
+  let oldestIndex = 0;
+  let oldestEntry = entries[oldestIndex];
+  if (!oldestEntry) {
+    entries.push(nextEntry);
+    return;
+  }
+
+  for (let index = 1; index < entries.length; index++) {
+    const entry = entries[index];
+    if (entry && entry.change.timestamp < oldestEntry.change.timestamp) {
+      oldestIndex = index;
+      oldestEntry = entry;
+    }
+  }
+
+  if (oldestEntry.change.timestamp <= nextEntry.change.timestamp) {
+    entries[oldestIndex] = nextEntry;
+  }
+}
+
 /**
  * Query change history across all persisted pi sessions.
  */
@@ -305,7 +342,8 @@ export async function queryGlobalHistory(
   sessionDir = DEFAULT_SESSION_DIR
 ): Promise<GlobalHistoryEntry[]> {
   const files = await walkSessionFiles(sessionDir);
-  const all: GlobalHistoryEntry[] = [];
+  const matchedEntries: GlobalHistoryEntry[] = [];
+  const limit = filters.limit ?? 20;
 
   for (const file of files) {
     let text: string;
@@ -335,16 +373,16 @@ export async function queryGlobalHistory(
       }
 
       const change = asChangeEntry(parsed.data);
-      if (change) {
-        all.push({ change, sessionFile: file });
+      if (!change || !matchesHistoryFilters(change, filters)) {
+        continue;
       }
+
+      pushGlobalHistoryEntry(matchedEntries, { change, sessionFile: file }, limit);
     }
   }
 
-  all.sort((a, b) => a.change.timestamp - b.change.timestamp);
-
-  const filtered = all.filter((entry) => matchesHistoryFilters(entry.change, filters));
-  return applyHistoryLimit(filtered, filters);
+  matchedEntries.sort((a, b) => a.change.timestamp - b.change.timestamp);
+  return matchedEntries;
 }
 
 /**

package/src/utils/mode.ts

@@ -1,7 +1,7 @@
 /**
  * UI capability helpers
  */
-import type { ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { type ExtensionCommandContext, type ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { notify } from "./notify.js";
 
 type AnyContext = ExtensionCommandContext | ExtensionContext;
@@ -66,7 +66,7 @@ export async function runCustomUI<T>(
   }
 
   const suffix = fallbackMessage ? ` ${fallbackMessage}` : "";
-  notify(ctx, `${featureName} requires the full interactive TUI.${suffix}`, "warning");
+  notify(ctx, `${featureName} is unavailable in the current UI mode.${suffix}`, "warning");
   return undefined;
 }
 

package/src/utils/notify.ts

@@ -1,7 +1,7 @@
 /**
  * Centralized notification handling for UI and non-UI modes
  */
-import type { ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { type ExtensionCommandContext, type ExtensionContext } from "@mariozechner/pi-coding-agent";
 
 export type NotifyLevel = "info" | "warning" | "error";
 
@@ -34,17 +34,3 @@ export function success(ctx: ExtensionCommandContext | ExtensionContext, message
 export function error(ctx: ExtensionCommandContext | ExtensionContext, message: string): void {
   notify(ctx, message, "error");
 }
-
-/**
- * Show warning message
- */
-export function warning(ctx: ExtensionCommandContext | ExtensionContext, message: string): void {
-  notify(ctx, message, "warning");
-}
-
-/**
- * Show info message
- */
-export function info(ctx: ExtensionCommandContext | ExtensionContext, message: string): void {
-  notify(ctx, message, "info");
-}

package/src/utils/npm-exec.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { execPath, platform } from "node:process";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { type ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
 interface NpmCommandResolutionOptions {
   platform?: NodeJS.Platform;

package/src/utils/package-source.ts

@@ -1,7 +1,11 @@
 /**
  * Package source parsing helpers shared across discovery/management flows.
  */
+import { homedir } from "node:os";
+import { join, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
 import { parseNpmSource } from "./format.js";
+import { normalizePathIdentity } from "./path-identity.js";
 
 export type PackageSourceKind = "npm" | "git" | "local" | "unknown";
 
@@ -49,11 +53,7 @@ export function getPackageSourceKind(source: string): PackageSourceKind {
 }
 
 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;
+  return normalizePathIdentity(source);
 }
 
 export function stripGitSourcePrefix(source: string): string {
@@ -61,9 +61,35 @@ export function stripGitSourcePrefix(source: string): string {
   return withoutGitPlus.startsWith("git:") ? withoutGitPlus.slice(4) : withoutGitPlus;
 }
 
+function resolveLocalSourceForIdentity(source: string, cwd?: string): string {
+  if (source.startsWith("file://")) {
+    try {
+      return fileURLToPath(source);
+    } catch {
+      return source;
+    }
+  }
+
+  if (source.startsWith("~/")) {
+    return join(homedir(), source.slice(2));
+  }
+
+  if (
+    cwd &&
+    (source.startsWith("./") ||
+      source.startsWith("../") ||
+      source.startsWith(".\\") ||
+      source.startsWith("..\\"))
+  ) {
+    return resolvePath(cwd, source);
+  }
+
+  return source;
+}
+
 export function normalizePackageIdentity(
   source: string,
-  options?: { resolvedPath?: string }
+  options?: { resolvedPath?: string; cwd?: string }
 ): string {
   const normalized = sanitizeSource(source);
   const kind = getPackageSourceKind(normalized);
@@ -80,7 +106,9 @@ export function normalizePackageIdentity(
   }
 
   if (kind === "local") {
-    return `local:${normalizeLocalSourceIdentity(options?.resolvedPath ?? normalized)}`;
+    const localSource =
+      options?.resolvedPath ?? resolveLocalSourceForIdentity(normalized, options?.cwd);
+    return `local:${normalizeLocalSourceIdentity(localSource)}`;
   }
 
   return `raw:${normalized.replace(/\\/g, "/").toLowerCase()}`;

package/src/utils/path-identity.ts

@@ -0,0 +1,7 @@
+export function normalizePathIdentity(value: string): string {
+  const normalized = value.replace(/\\/g, "/");
+  const looksWindowsPath =
+    /^[a-zA-Z]:\//.test(normalized) || normalized.startsWith("//") || value.includes("\\");
+
+  return looksWindowsPath ? normalized.toLowerCase() : normalized;
+}

package/src/utils/relative-path-selection.ts

@@ -0,0 +1,100 @@
+import { matchesGlob } from "node:path";
+
+export function normalizeRelativePath(value: string): string {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+export function hasGlobMagic(path: string): boolean {
+  return /[*?{}[\]]/.test(path);
+}
+
+export function isSafeRelativePath(path: string): boolean {
+  const normalizedPath = path.replace(/\\/g, "/");
+
+  return (
+    normalizedPath !== "" &&
+    normalizedPath !== ".." &&
+    !normalizedPath.startsWith("/") &&
+    !path.startsWith("\\") &&
+    !/^[A-Za-z]:/.test(normalizedPath) &&
+    !normalizedPath.startsWith("../") &&
+    !normalizedPath.includes("/../") &&
+    !normalizedPath.endsWith("/..")
+  );
+}
+
+export function safeMatchesGlob(targetPath: string, pattern: string): boolean {
+  try {
+    return matchesGlob(targetPath, pattern);
+  } catch {
+    return false;
+  }
+}
+
+export function matchesFilterPattern(targetPath: string, pattern: string): boolean {
+  const normalizedPattern = normalizeRelativePath(pattern.trim());
+  if (!normalizedPattern) return false;
+  if (targetPath === normalizedPattern) return true;
+
+  return safeMatchesGlob(targetPath, normalizedPattern);
+}
+
+export function selectDirectoryFiles(allFiles: readonly string[], directoryPath: string): string[] {
+  const prefix = `${directoryPath}/`;
+  return allFiles.filter((file) => file.startsWith(prefix));
+}
+
+export function applySelection(
+  selected: Set<string>,
+  files: Iterable<string>,
+  exclude: boolean
+): void {
+  for (const file of files) {
+    if (exclude) {
+      selected.delete(file);
+    } else {
+      selected.add(file);
+    }
+  }
+}
+
+export function resolveRelativePathSelection(
+  allFiles: readonly string[],
+  entries: readonly string[],
+  isExactPathSelectable: (path: string, allFiles: readonly string[]) => boolean
+): string[] {
+  const selected = new Set<string>();
+
+  for (const rawToken of entries) {
+    const token = rawToken.trim();
+    if (!token) continue;
+
+    const exclude = token.startsWith("!");
+    const normalizedToken = normalizeRelativePath(exclude ? token.slice(1) : token);
+    const pattern = normalizedToken.replace(/[\\/]+$/g, "");
+    if (!isSafeRelativePath(pattern)) {
+      continue;
+    }
+
+    if (hasGlobMagic(pattern)) {
+      applySelection(
+        selected,
+        allFiles.filter((file) => matchesFilterPattern(file, pattern)),
+        exclude
+      );
+      continue;
+    }
+
+    const directoryFiles = selectDirectoryFiles(allFiles, pattern);
+    if (directoryFiles.length > 0) {
+      applySelection(selected, directoryFiles, exclude);
+      continue;
+    }
+
+    if (isExactPathSelectable(pattern, allFiles)) {
+      applySelection(selected, [pattern], exclude);
+    }
+  }
+
+  return Array.from(selected).sort((a, b) => a.localeCompare(b));
+}

package/src/utils/settings.ts

@@ -2,14 +2,16 @@
  * Auto-update settings storage
  * Persists to disk so config survives across pi sessions.
  */
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { readFile, writeFile, mkdir, rename, rm } from "node:fs/promises";
+
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import {
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { parseScheduleDuration } from "./duration.js";
 import { fileExists } from "./fs.js";
 import { normalizePackageIdentity } from "./package-source.js";
 
@@ -303,63 +305,11 @@ export function clearUpdatesAvailable(
 }
 
 /**
- * Parse duration string to milliseconds
- * Supports: 1h, 2h, 1d, 7d, 1m, 3m, etc.
- * Also supports: never, off, disable, daily, weekly
+ * Parse schedule duration strings for auto-update settings.
+ * Supports hours/days/weeks/months plus schedule aliases like `daily`, `weekly`, and `never`.
  */
 export function parseDuration(input: string): { ms: number; display: string } | undefined {
-  const normalized = input.toLowerCase().trim();
-
-  // Special cases for disabling
-  if (normalized === "never" || normalized === "off" || normalized === "disable") {
-    return { ms: 0, display: "off" };
-  }
-
-  // Named schedules
-  if (normalized === "daily" || normalized === "day" || normalized === "1d") {
-    return { ms: 24 * 60 * 60 * 1000, display: "daily" };
-  }
-  if (normalized === "weekly" || normalized === "week" || normalized === "1w") {
-    return { ms: 7 * 24 * 60 * 60 * 1000, display: "weekly" };
-  }
-
-  // Parse duration patterns: 1h, 2h, 3d, 7d, 1m, etc.
-  const durationMatch = normalized.match(
-    /^(\d+)\s*(h|hr|hrs|hour|hours|d|day|days|w|wk|wks|week|weeks|m|mo|mos|month|months)$/
-  );
-  if (durationMatch) {
-    const value = parseInt(durationMatch[1]!, 10);
-    const unit = durationMatch[2]![0]; // First character of unit
-
-    let ms: number;
-    let display: string;
-
-    switch (unit) {
-      case "h":
-        ms = value * 60 * 60 * 1000;
-        display = value === 1 ? "1 hour" : `${value} hours`;
-        break;
-      case "d":
-        ms = value * 24 * 60 * 60 * 1000;
-        display = value === 1 ? "1 day" : `${value} days`;
-        break;
-      case "w":
-        ms = value * 7 * 24 * 60 * 60 * 1000;
-        display = value === 1 ? "1 week" : `${value} weeks`;
-        break;
-      case "m":
-        // Approximate months as 30 days
-        ms = value * 30 * 24 * 60 * 60 * 1000;
-        display = value === 1 ? "1 month" : `${value} months`;
-        break;
-      default:
-        return undefined;
-    }
-
-    return { ms, display };
-  }
-
-  return undefined;
+  return parseScheduleDuration(input);
 }
 
 /**

package/src/utils/status.ts

@@ -1,10 +1,11 @@
 /**
  * Status bar helpers for extmgr
  */
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
+import {
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+  getAgentDir,
 } from "@mariozechner/pi-coding-agent";
 import { getPackageCatalog, type PackageCatalog } from "../packages/catalog.js";
 import { getAutoUpdateStatus } from "./auto-update.js";
@@ -15,14 +16,15 @@ type CatalogInstalledPackages = Awaited<ReturnType<PackageCatalog["listInstalled
 
 function filterStaleUpdates(
   knownUpdates: string[],
-  installedPackages: CatalogInstalledPackages
+  installedPackages: CatalogInstalledPackages,
+  cwd: string
 ): string[] {
   const installedIdentities = new Set(
     installedPackages.map((pkg) =>
-      normalizePackageIdentity(
-        pkg.source,
-        pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : undefined
-      )
+      normalizePackageIdentity(pkg.source, {
+        ...(pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : {}),
+        cwd: pkg.scope === "project" ? cwd : getAgentDir(),
+      })
     )
   );
   return knownUpdates.filter((identity) => installedIdentities.has(identity));
@@ -52,7 +54,7 @@ export async function updateExtmgrStatus(
 
     // Validate updates against actually installed packages (handles external pi update)
     const knownUpdates = autoUpdateConfig.updatesAvailable ?? [];
-    const validUpdates = filterStaleUpdates(knownUpdates, packages);
+    const validUpdates = filterStaleUpdates(knownUpdates, packages, ctx.cwd);
 
     // If stale updates were filtered, persist the correction
     if (validUpdates.length !== knownUpdates.length) {

package/src/utils/ui-helpers.ts

@@ -1,9 +1,9 @@
 /**
  * Common UI helper patterns
  */
-import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
-import { notify } from "./notify.js";
+import { type ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { UI } from "../constants.js";
+import { notify } from "./notify.js";
 
 /**
  * Confirm and trigger reload

package/src/utils/retry.ts

@@ -1,49 +0,0 @@
-/**
- * Retry utilities for async operations
- */
-
-export interface RetryOptions {
-  maxAttempts?: number;
-  delayMs?: number;
-  backoff?: "fixed" | "linear" | "exponential";
-}
-
-export async function retryWithBackoff<T>(
-  operation: () => Promise<T | undefined>,
-  options: RetryOptions = {}
-): Promise<T | undefined> {
-  const { maxAttempts = 5, delayMs = 100, backoff = "exponential" } = options;
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const result = await operation();
-    if (result !== undefined) {
-      return result;
-    }
-
-    if (attempt < maxAttempts) {
-      const delay =
-        backoff === "exponential"
-          ? delayMs * Math.pow(2, attempt - 1)
-          : backoff === "linear"
-            ? delayMs * attempt
-            : delayMs;
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
-  }
-
-  return undefined;
-}
-
-/**
- * Wait for a condition to be true with timeout
- */
-export async function waitForCondition(
-  condition: () => Promise<boolean> | boolean,
-  options: RetryOptions = {}
-): Promise<boolean> {
-  const result = await retryWithBackoff(async () => {
-    const value = await condition();
-    return value ? true : undefined;
-  }, options);
-  return result === true;
-}