pi-extmgr 0.1.28 → 0.2.0

package/src/utils/history.ts

@@ -299,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.
  */
@@ -307,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;
@@ -337,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

@@ -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

@@ -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/package-source.ts

@@ -5,6 +5,7 @@ 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";
 
@@ -52,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 {

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

@@ -11,6 +11,7 @@ import {
   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";
 
@@ -304,71 +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 [, rawValue, rawUnit] = durationMatch;
-    if (!rawValue || !rawUnit) {
-      return undefined;
-    }
-
-    const value = Number.parseInt(rawValue, 10);
-    const unit = rawUnit[0];
-    if (!unit) {
-      return undefined;
-    }
-
-    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/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 * 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;
-}