pi-extmgr 0.1.28 → 0.2.0

package/src/utils/auto-update.ts

@@ -7,6 +7,7 @@ import {
   type ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
 import { getPackageCatalog } from "../packages/catalog.js";
+import { parseChoiceByLabel } from "./command.js";
 import { logAutoUpdateConfig } from "./history.js";
 import { notify } from "./notify.js";
 import { normalizePackageIdentity } from "./package-source.js";
@@ -21,6 +22,15 @@ import {
 
 import { isTimerRunning, startTimer, stopTimer } from "./timer.js";
 
+const AUTO_UPDATE_WIZARD_CHOICES = {
+  off: "Off",
+  hour: "Every hour",
+  daily: "Daily",
+  weekly: "Weekly",
+  custom: "Custom...",
+  cancel: "Cancel",
+} as const;
+
 // Context provider for safe session handling
 export type ContextProvider = () => (ExtensionCommandContext | ExtensionContext) | undefined;
 
@@ -148,35 +158,30 @@ export async function promptAutoUpdateWizard(
   }
 
   const current = getAutoUpdateConfig(ctx);
-  const choice = await ctx.ui.select(`Auto-update (${current.displayText})`, [
-    "Off",
-    "Every hour",
-    "Daily",
-    "Weekly",
-    "Custom...",
-    "Cancel",
-  ]);
-
-  if (!choice || choice === "Cancel") return;
-
-  if (choice === "Off") {
-    disableAutoUpdate(pi, ctx);
-    return;
-  }
-
-  if (choice === "Every hour") {
-    enableAutoUpdate(pi, ctx, 60 * 60 * 1000, "1 hour", onUpdateAvailable);
-    return;
-  }
-
-  if (choice === "Daily") {
-    enableAutoUpdate(pi, ctx, 24 * 60 * 60 * 1000, "daily", onUpdateAvailable);
-    return;
-  }
+  const choice = parseChoiceByLabel(
+    AUTO_UPDATE_WIZARD_CHOICES,
+    await ctx.ui.select(
+      `Auto-update (${current.displayText})`,
+      Object.values(AUTO_UPDATE_WIZARD_CHOICES)
+    )
+  );
 
-  if (choice === "Weekly") {
-    enableAutoUpdate(pi, ctx, 7 * 24 * 60 * 60 * 1000, "weekly", onUpdateAvailable);
-    return;
+  switch (choice) {
+    case "off":
+      disableAutoUpdate(pi, ctx);
+      return;
+    case "hour":
+      enableAutoUpdate(pi, ctx, 60 * 60 * 1000, "1 hour", onUpdateAvailable);
+      return;
+    case "daily":
+      enableAutoUpdate(pi, ctx, 24 * 60 * 60 * 1000, "daily", onUpdateAvailable);
+      return;
+    case "weekly":
+      enableAutoUpdate(pi, ctx, 7 * 24 * 60 * 60 * 1000, "weekly", onUpdateAvailable);
+      return;
+    case "cancel":
+    case undefined:
+      return;
   }
 
   const input = await ctx.ui.input("Auto-update interval", current.displayText || "1d");
@@ -184,7 +189,7 @@ export async function promptAutoUpdateWizard(
 
   const parsed = parseDuration(input.trim());
   if (!parsed) {
-    notify(ctx, "Invalid duration. Examples: 1h, 1d, 1w, 1m, never", "warning");
+    notify(ctx, "Invalid duration. Examples: 1h, 1d, 1w, 1mo, never", "warning");
     return;
   }
 

package/src/utils/cache.ts

@@ -13,13 +13,27 @@ const CACHE_DIR = process.env.PI_EXTMGR_CACHE_DIR
   : join(homedir(), ".pi", "agent", ".extmgr-cache");
 const CACHE_FILE = join(CACHE_DIR, "metadata.json");
 const CURRENT_SEARCH_CACHE_STRATEGY = "npm-registry-v1-paginated";
+const CACHED_PACKAGE_FIELDS = [
+  "description",
+  "version",
+  "author",
+  "keywords",
+  "date",
+  "size",
+] as const;
+
+type CachedPackageField = (typeof CACHED_PACKAGE_FIELDS)[number];
 
 interface CachedPackageData {
   name: string;
   description?: string | undefined;
   version?: string | undefined;
+  author?: string | undefined;
+  keywords?: string[] | undefined;
+  date?: string | undefined;
   size?: number | undefined;
   timestamp: number;
+  fieldTimestamps?: Partial<Record<CachedPackageField, number>> | undefined;
 }
 
 interface CacheData {
@@ -55,17 +69,66 @@ function normalizeCachedPackageEntry(key: string, value: unknown): CachedPackage
     name,
     timestamp,
   };
+  const rawFieldTimestamps = isRecord(value.fieldTimestamps) ? value.fieldTimestamps : undefined;
+
+  const getFieldTimestamp = (field: CachedPackageField): number => {
+    const fieldTimestamp = rawFieldTimestamps?.[field];
+    return typeof fieldTimestamp === "number" &&
+      Number.isFinite(fieldTimestamp) &&
+      fieldTimestamp > 0
+      ? fieldTimestamp
+      : timestamp;
+  };
 
   if (typeof value.description === "string") {
     entry.description = value.description;
+    entry.fieldTimestamps = {
+      ...entry.fieldTimestamps,
+      description: getFieldTimestamp("description"),
+    };
   }
 
   if (typeof value.version === "string") {
     entry.version = value.version;
+    entry.fieldTimestamps = {
+      ...entry.fieldTimestamps,
+      version: getFieldTimestamp("version"),
+    };
+  }
+
+  if (typeof value.author === "string") {
+    entry.author = value.author;
+    entry.fieldTimestamps = {
+      ...entry.fieldTimestamps,
+      author: getFieldTimestamp("author"),
+    };
+  }
+
+  if (Array.isArray(value.keywords)) {
+    const keywords = value.keywords.filter((item): item is string => typeof item === "string");
+    if (keywords.length > 0) {
+      entry.keywords = keywords;
+      entry.fieldTimestamps = {
+        ...entry.fieldTimestamps,
+        keywords: getFieldTimestamp("keywords"),
+      };
+    }
+  }
+
+  if (typeof value.date === "string") {
+    entry.date = value.date;
+    entry.fieldTimestamps = {
+      ...entry.fieldTimestamps,
+      date: getFieldTimestamp("date"),
+    };
   }
 
   if (typeof value.size === "number" && Number.isFinite(value.size) && value.size >= 0) {
     entry.size = value.size;
+    entry.fieldTimestamps = {
+      ...entry.fieldTimestamps,
+      size: getFieldTimestamp("size"),
+    };
   }
 
   return entry;
@@ -234,11 +297,117 @@ async function enqueueCacheSave(): Promise<void> {
   return cacheWriteQueue;
 }
 
+function setCachedPackageField(
+  data: CachedPackageData,
+  field: CachedPackageField,
+  value: CachedPackageData[CachedPackageField],
+  timestamp: number
+): void {
+  switch (field) {
+    case "description":
+      data.description = value as string | undefined;
+      break;
+    case "version":
+      data.version = value as string | undefined;
+      break;
+    case "author":
+      data.author = value as string | undefined;
+      break;
+    case "keywords":
+      data.keywords = value as string[] | undefined;
+      break;
+    case "date":
+      data.date = value as string | undefined;
+      break;
+    case "size":
+      data.size = value as number | undefined;
+      break;
+  }
+
+  data.fieldTimestamps = {
+    ...data.fieldTimestamps,
+    [field]: timestamp,
+  };
+}
+
+function getCachedFieldTimestamp(data: CachedPackageData, field: CachedPackageField): number {
+  return data.fieldTimestamps?.[field] ?? data.timestamp;
+}
+
+function mergeCachedPackageData(
+  existing: CachedPackageData | undefined,
+  next: Omit<CachedPackageData, "timestamp" | "fieldTimestamps">
+): CachedPackageData {
+  const timestamp = Date.now();
+  const merged: CachedPackageData = {
+    name: next.name || existing?.name || "",
+    timestamp,
+  };
+
+  for (const field of CACHED_PACKAGE_FIELDS) {
+    const nextValue = next[field];
+    if (nextValue !== undefined) {
+      setCachedPackageField(merged, field, nextValue, timestamp);
+      continue;
+    }
+
+    const existingValue = existing?.[field];
+    if (existingValue !== undefined && existing) {
+      setCachedPackageField(merged, field, existingValue, getCachedFieldTimestamp(existing, field));
+    }
+  }
+
+  return merged;
+}
+
 /**
  * Check if cached data is still valid (within TTL)
  */
-function isCacheValid(timestamp: number): boolean {
-  return Date.now() - timestamp < CACHE_LIMITS.metadataTTL;
+function isCacheValid(timestamp: number | undefined): boolean {
+  return typeof timestamp === "number" && Date.now() - timestamp < CACHE_LIMITS.metadataTTL;
+}
+
+function getFreshCachedField(
+  data: CachedPackageData,
+  field: CachedPackageField
+): CachedPackageData[CachedPackageField] | undefined {
+  const value = data[field];
+  if (value === undefined) {
+    return undefined;
+  }
+
+  return isCacheValid(getCachedFieldTimestamp(data, field)) ? value : undefined;
+}
+
+function hasFreshCachedField(data: CachedPackageData): boolean {
+  return CACHED_PACKAGE_FIELDS.some((field) => {
+    const value = data[field];
+    return value !== undefined && isCacheValid(getCachedFieldTimestamp(data, field));
+  });
+}
+
+function toFreshCachedPackage(data: CachedPackageData | undefined): CachedPackageData | null {
+  if (!data) {
+    return null;
+  }
+
+  const fresh: CachedPackageData = {
+    name: data.name,
+    timestamp: data.timestamp,
+  };
+  let hasFreshField = false;
+
+  for (const field of CACHED_PACKAGE_FIELDS) {
+    const value = getFreshCachedField(data, field);
+    if (value === undefined) {
+      continue;
+    }
+
+    hasFreshField = true;
+    setCachedPackageField(fresh, field, value, getCachedFieldTimestamp(data, field));
+  }
+
+  return hasFreshField ? fresh : null;
 }
 
 /**
@@ -246,13 +415,7 @@ function isCacheValid(timestamp: number): boolean {
  */
 export async function getCachedPackage(name: string): Promise<CachedPackageData | null> {
   const cache = await loadCache();
-  const data = cache.packages.get(name);
-
-  if (!data || !isCacheValid(data.timestamp)) {
-    return null;
-  }
-
-  return data;
+  return toFreshCachedPackage(cache.packages.get(name));
 }
 
 /**
@@ -260,13 +423,10 @@ export async function getCachedPackage(name: string): Promise<CachedPackageData
  */
 export async function setCachedPackage(
   name: string,
-  data: Omit<CachedPackageData, "timestamp">
+  data: Omit<CachedPackageData, "timestamp" | "fieldTimestamps">
 ): Promise<void> {
   const cache = await loadCache();
-  cache.packages.set(name, {
-    ...data,
-    timestamp: Date.now(),
-  });
+  cache.packages.set(name, mergeCachedPackageData(cache.packages.get(name), data));
   await enqueueCacheSave();
 }
 
@@ -295,8 +455,12 @@ export async function getCachedSearch(query: string): Promise<NpmPackage[] | nul
     if (pkg) {
       packages.push({
         name: pkg.name,
-        description: pkg.description ?? undefined,
-        version: pkg.version ?? undefined,
+        description: getFreshCachedField(pkg, "description") as string | undefined,
+        version: getFreshCachedField(pkg, "version") as string | undefined,
+        author: getFreshCachedField(pkg, "author") as string | undefined,
+        keywords: getFreshCachedField(pkg, "keywords") as string[] | undefined,
+        date: getFreshCachedField(pkg, "date") as string | undefined,
+        size: getFreshCachedField(pkg, "size") as number | undefined,
       });
     }
   }
@@ -312,12 +476,18 @@ export async function setCachedSearch(query: string, packages: NpmPackage[]): Pr
 
   // Update cache with new packages
   for (const pkg of packages) {
-    cache.packages.set(pkg.name, {
-      name: pkg.name,
-      description: pkg.description ?? undefined,
-      version: pkg.version ?? undefined,
-      timestamp: Date.now(),
-    });
+    cache.packages.set(
+      pkg.name,
+      mergeCachedPackageData(cache.packages.get(pkg.name), {
+        name: pkg.name,
+        description: pkg.description ?? undefined,
+        version: pkg.version ?? undefined,
+        author: pkg.author ?? undefined,
+        keywords: pkg.keywords ?? undefined,
+        date: pkg.date ?? undefined,
+        size: pkg.size ?? undefined,
+      })
+    );
   }
 
   // Store search results
@@ -355,7 +525,7 @@ export async function getCacheStats(): Promise<{
   let expired = 0;
 
   for (const [, data] of cache.packages) {
-    if (isCacheValid(data.timestamp)) {
+    if (hasFreshCachedField(data)) {
       valid++;
     } else {
       expired++;
@@ -383,8 +553,9 @@ export async function getPackageDescriptions(
     if (!npmSource?.name) continue;
 
     const cached = cache.packages.get(npmSource.name);
-    if (cached?.description && isCacheValid(cached.timestamp)) {
-      descriptions.set(pkg.source, cached.description);
+    const description = cached ? getFreshCachedField(cached, "description") : undefined;
+    if (typeof description === "string") {
+      descriptions.set(pkg.source, description);
     }
   }
 
@@ -397,12 +568,7 @@ export async function getPackageDescriptions(
 export async function getCachedPackageSize(name: string): Promise<number | undefined> {
   const cache = await loadCache();
   const data = cache.packages.get(name);
-
-  if (data && isCacheValid(data.timestamp)) {
-    return data.size;
-  }
-
-  return undefined;
+  return data ? (getFreshCachedField(data, "size") as number | undefined) : undefined;
 }
 
 /**
@@ -412,14 +578,19 @@ export async function setCachedPackageSize(name: string, size: number): Promise<
   const cache = await loadCache();
   const existing = cache.packages.get(name);
 
+  const timestamp = Date.now();
+
   if (existing) {
-    existing.size = size;
-    existing.timestamp = Date.now();
+    existing.timestamp = timestamp;
+    setCachedPackageField(existing, "size", size, timestamp);
   } else {
     cache.packages.set(name, {
       name,
       size,
-      timestamp: Date.now(),
+      timestamp,
+      fieldTimestamps: {
+        size: timestamp,
+      },
     });
   }
 

package/src/utils/duration.ts

@@ -0,0 +1,132 @@
+export type DurationUnit = "minute" | "hour" | "day" | "week" | "month";
+
+interface ParsedDuration {
+  ms: number;
+  display: string;
+}
+
+interface DurationAlias {
+  ms: number;
+  display: string;
+}
+
+interface DurationUnitDefinition {
+  aliases: readonly string[];
+  ms: number;
+  singular: string;
+  plural: string;
+}
+
+interface ParseDurationOptions {
+  allowedUnits: readonly DurationUnit[];
+  aliases?: Readonly<Record<string, DurationAlias>>;
+}
+
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const WEEK_MS = 7 * DAY_MS;
+const MONTH_MS = 30 * DAY_MS;
+
+const DURATION_UNITS: Record<DurationUnit, DurationUnitDefinition> = {
+  minute: {
+    aliases: ["m", "min", "mins", "minute", "minutes"],
+    ms: 60 * 1000,
+    singular: "minute",
+    plural: "minutes",
+  },
+  hour: {
+    aliases: ["h", "hr", "hrs", "hour", "hours"],
+    ms: HOUR_MS,
+    singular: "hour",
+    plural: "hours",
+  },
+  day: {
+    aliases: ["d", "day", "days"],
+    ms: DAY_MS,
+    singular: "day",
+    plural: "days",
+  },
+  week: {
+    aliases: ["w", "wk", "wks", "week", "weeks"],
+    ms: WEEK_MS,
+    singular: "week",
+    plural: "weeks",
+  },
+  month: {
+    aliases: ["mo", "mos", "month", "months"],
+    ms: MONTH_MS,
+    singular: "month",
+    plural: "months",
+  },
+};
+
+function formatDisplay(value: number, unit: DurationUnit): string {
+  const definition = DURATION_UNITS[unit];
+  return `${value} ${value === 1 ? definition.singular : definition.plural}`;
+}
+
+function findDurationUnit(
+  rawUnit: string,
+  allowedUnits: readonly DurationUnit[]
+): DurationUnit | undefined {
+  return allowedUnits.find((unit) => DURATION_UNITS[unit].aliases.includes(rawUnit));
+}
+
+export function parseDurationValue(
+  input: string,
+  options: ParseDurationOptions
+): ParsedDuration | undefined {
+  const normalized = input.toLowerCase().trim();
+  if (!normalized) {
+    return undefined;
+  }
+
+  const alias = options.aliases?.[normalized];
+  if (alias) {
+    return { ...alias };
+  }
+
+  const match = normalized.match(/^(\d+)\s*([a-z]+)$/i);
+  if (!match) {
+    return undefined;
+  }
+
+  const value = Number.parseInt(match[1] ?? "", 10);
+  const rawUnit = match[2] ?? "";
+  if (!Number.isFinite(value) || value <= 0 || !rawUnit) {
+    return undefined;
+  }
+
+  const unit = findDurationUnit(rawUnit, options.allowedUnits);
+  if (!unit) {
+    return undefined;
+  }
+
+  return {
+    ms: value * DURATION_UNITS[unit].ms,
+    display: formatDisplay(value, unit),
+  };
+}
+
+const SCHEDULE_DURATION_ALIASES = {
+  never: { ms: 0, display: "off" },
+  off: { ms: 0, display: "off" },
+  disable: { ms: 0, display: "off" },
+  daily: { ms: DAY_MS, display: "daily" },
+  day: { ms: DAY_MS, display: "daily" },
+  weekly: { ms: WEEK_MS, display: "weekly" },
+  week: { ms: WEEK_MS, display: "weekly" },
+} satisfies Record<string, DurationAlias>;
+
+export function parseScheduleDuration(input: string): ParsedDuration | undefined {
+  return parseDurationValue(input, {
+    allowedUnits: ["hour", "day", "week", "month"],
+    aliases: SCHEDULE_DURATION_ALIASES,
+  });
+}
+
+export function parseLookbackDuration(input: string): number | undefined {
+  return parseDurationValue(input, {
+    allowedUnits: ["minute", "hour", "day", "week", "month"],
+  })?.ms;
+}

package/src/utils/format.ts

@@ -9,36 +9,6 @@ export function truncate(text: string, maxLength: number): string {
   return `${text.slice(0, maxLength - 3)}...`;
 }
 
-/**
- * Get the terminal width, with a minimum fallback
- */
-export function getTerminalWidth(minWidth = 80): number {
-  return Math.max(minWidth, process.stdout.columns || minWidth);
-}
-
-/**
- * Calculate available space for description based on fixed-width elements
- */
-export function getDescriptionWidth(
-  totalWidth: number,
-  reservedSpace: number,
-  minDescWidth = 20
-): number {
-  return Math.max(minDescWidth, totalWidth - reservedSpace);
-}
-
-/**
- * Dynamic truncate that adapts to available terminal width
- * @param text - Text to truncate
- * @param reservedSpace - Space taken by fixed elements (icons, name, version, etc.)
- * @param minWidth - Minimum terminal width to consider
- */
-export function dynamicTruncate(text: string, reservedSpace: number, minWidth = 80): string {
-  const termWidth = getTerminalWidth(minWidth);
-  const maxDescWidth = getDescriptionWidth(termWidth, reservedSpace);
-  return truncate(text, maxDescWidth);
-}
-
 export function formatEntry(entry: ExtensionEntry): string {
   const state = entry.state === "enabled" ? "on " : "off";
   const scope = entry.scope === "global" ? "G" : "P";

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