@pi-stef/catalog 0.3.5 → 0.5.0

package/src/commands/add.ts

@@ -2,7 +2,7 @@
  * `ct add` subcommand implementation.
  *
  * Adds a new package to the catalog. Supports:
- *   - Full args: `ct add <name> <source> [--rating <r>] [--type <t>]`
+ *   - Full args: `ct add <source> [--type <t>]`
  *   - Git source without `--type`: prompts for type via `ctx.ui.select()`
  *   - After adding, runs `pi install` to install the package
  *
@@ -10,9 +10,11 @@
  * and `writeCatalog` / `readCatalog` for persistence.
  */
 
-import type { RatingValue } from "../catalog/ratings.js";
 import type { CommandArgs, CommandCtx } from "./types.js";
 import { addPackage } from "../catalog/crud.js";
+import { sourceToKey } from "../catalog/source.js";
+import { checkSetupForSource, formatSetupStatus } from "../catalog/setup.js";
+import { PI_STEF_PACKAGES } from "../catalog/packages.js";
 import { readCatalog, writeCatalog } from "../config/io.js";
 import { piInstall } from "../util/exec.js";
 
@@ -34,25 +36,6 @@ export interface AddCtx extends CommandCtx {
 // Helpers
 // ---------------------------------------------------------------------------
 
-const VALID_RATINGS: RatingValue[] = ["core", "useful", "debatable"];
-
-function isValidRating(value: string): value is RatingValue {
-  return VALID_RATINGS.includes(value as RatingValue);
-}
-
-function resolveRating(flags: Record<string, true | string>): RatingValue {
-  const raw =
-    "r" in flags
-      ? flags["r"]
-      : "rating" in flags
-        ? flags["rating"]
-        : undefined;
-
-  if (raw === true || raw === undefined) return "core";
-  if (typeof raw === "string" && isValidRating(raw)) return raw;
-  return "core";
-}
-
 function resolveType(
   flags: Record<string, true | string>,
 ): "skill" | "pi-native" | undefined {
@@ -75,24 +58,115 @@ function resolveType(
 /**
  * Execute the `ct add` subcommand.
  *
+ * New syntax (preferred): `ct add <source> [--type ...]`
+ *   — name is auto-derived from source via `sourceToKey()`.
+ *
+ * Legacy syntax (deprecated): `ct add <name> <source> [--type ...]`
+ *   — still accepted but emits a deprecation warning.
+ *
  * Reads the catalog, validates inputs, prompts for type if needed,
  * adds the package, writes the catalog, and runs `pi install`.
  */
 export async function addCommand(args: CommandArgs, ctx: AddCtx): Promise<void> {
   const { positional, flags } = args;
-  const name = positional[0];
-  const source = positional[1];
 
-  // --- Validate required args -----------------------------------------------
-  if (!name || !source) {
+  // --- Handle --scope batch mode ---------------------------------------------
+  if ("scope" in flags) {
+    const scope = flags["scope"];
+    if (scope !== "@pi-stef") {
+      ctx.ui.notify(`Unsupported scope: "${scope}". Use --scope @pi-stef.`, "error");
+      return;
+    }
+
+    const catalog = readCatalog(ctx.home);
+    let added = 0;
+    let skipped = 0;
+    let currentCatalog = catalog;
+
+    for (const pkg of PI_STEF_PACKAGES) {
+      const npmSource = `npm:${pkg}`;
+
+      // Skip if already in catalog
+      if (currentCatalog.packages[pkg]) {
+        skipped++;
+        continue;
+      }
+
+      try {
+        currentCatalog = addPackage(currentCatalog, pkg, npmSource);
+        added++;
+      } catch (err: unknown) {
+        // Unexpected validation error — warn but continue
+        ctx.ui.notify(
+          `Warning: failed to add "${pkg}": ${err instanceof Error ? err.message : String(err)}`,
+          "warning",
+        );
+        skipped++;
+      }
+    }
+
+    if (added > 0) {
+      writeCatalog(currentCatalog, ctx.home);
+    }
+
+    // Install all added packages
+    const setupWarnings: string[] = [];
+    if (added > 0) {
+      for (const pkg of PI_STEF_PACKAGES) {
+        if (currentCatalog.packages[pkg]?.source === `npm:${pkg}`) {
+          ctx.ui.setWorkingMessage?.(`Installing ${pkg}...`);
+          try {
+            await piInstall(`npm:${pkg}`);
+
+            // Check setup after successful install
+            const setup = checkSetupForSource(`npm:${pkg}`, ctx.home);
+            if (setup && !setup.ok) {
+              setupWarnings.push(`${pkg}: ${formatSetupStatus(setup)}`);
+            }
+          } catch {
+            ctx.ui.notify(`Warning: install of "${pkg}" failed`, "warning");
+          }
+        }
+      }
+      ctx.ui.setWorkingMessage?.();
+    }
+
+    const parts: string[] = [
+      `Scope @pi-stef: added ${added}, skipped ${skipped} (already in catalog)`,
+    ];
+    if (setupWarnings.length > 0) {
+      parts.push(`Setup incomplete:\n  ${setupWarnings.join("\n  ")}`);
+    }
+
+    ctx.ui.notify(
+      parts.join("\n"),
+      setupWarnings.length > 0 ? "warning" : "info",
+    );
+    return;
+  }
+
+  // --- Handle legacy 2-arg syntax: ct add <name> <source> -------------------
+  let name: string;
+  let source: string;
+
+  if (positional.length >= 2) {
+    name = positional[0];
+    source = positional[1];
     ctx.ui.notify(
-      "Usage: ct add <name> <source> [--rating <core|useful|debatable>] [--type <skill|pi-native>]",
+      `"ct add <name> <source>" is legacy. Use "ct add <source>" — name is auto-derived.`,
+      "warning",
+    );
+  } else if (positional.length === 1) {
+    source = positional[0];
+    name = sourceToKey(source);
+  } else {
+    ctx.ui.notify(
+      "Usage: ct add <source> [--type <skill|pi-native>]",
       "error",
     );
     return;
   }
 
-  const rating = resolveRating(flags);
   let type = resolveType(flags);
 
   // --- Read catalog ---------------------------------------------------------
@@ -113,7 +187,7 @@ export async function addCommand(args: CommandArgs, ctx: AddCtx): Promise<void>
 
   // --- Add package ----------------------------------------------------------
   try {
-    const updated = addPackage(catalog, name, source, rating, type);
+    const updated = addPackage(catalog, name, source, type);
     writeCatalog(updated, ctx.home);
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : String(err);
@@ -124,6 +198,7 @@ export async function addCommand(args: CommandArgs, ctx: AddCtx): Promise<void>
   ctx.ui.notify(`Added "${name}" to catalog`, "info");
 
   // --- Run pi install -------------------------------------------------------
+  ctx.ui.setWorkingMessage?.(`Installing ${name}...`);
   try {
     await piInstall(source);
   } catch {
@@ -132,4 +207,14 @@ export async function addCommand(args: CommandArgs, ctx: AddCtx): Promise<void>
       "warning",
     );
   }
+  ctx.ui.setWorkingMessage?.();
+
+  // --- Check setup requirements ---------------------------------------------
+  const setup = checkSetupForSource(source, ctx.home);
+  if (setup && !setup.ok) {
+    ctx.ui.notify(
+      `Setup incomplete for "${name}": ${formatSetupStatus(setup)}`,
+      "warning",
+    );
+  }
 }

package/src/commands/definitions.ts

@@ -30,7 +30,8 @@ export const SUBCOMMAND_DEFS: readonly SubcommandDef[] = [
   { name: "init", description: "Initialize a new catalog" },
   { name: "add", aliases: ["a"], description: "Add a package to the catalog" },
   { name: "remove", aliases: ["rm"], description: "Remove a package from the catalog" },
-  { name: "toggle", description: "Toggle a package's rating" },
+  { name: "toggle", description: "Toggle a package's enabled state" },
+  { name: "update", aliases: ["up"], description: "Update packages to latest versions" },
   { name: "disable", description: "Disable a package" },
   { name: "enable", description: "Enable a package" },
   { name: "push", description: "Push catalog to remote gist" },
@@ -41,6 +42,7 @@ export const SUBCOMMAND_DEFS: readonly SubcommandDef[] = [
   { name: "verify", description: "Verify catalog integrity" },
   { name: "profiles", description: "List available profiles" },
   { name: "profile", description: "Show or switch active profile" },
+  { name: "reset", description: "Reset catalog: uninstall all @pi-stef packages and delete config" },
 ] as const;
 
 // ---------------------------------------------------------------------------

package/src/commands/init.ts

@@ -8,6 +8,7 @@
 import yaml from "js-yaml";
 
 import { scanInstalled } from "../catalog/install.js";
+import { migrateRatingToEnabledRaw } from "../catalog/migrate.js";
 import { CatalogYamlSchema } from "../config/schema.js";
 import type { CatalogYaml } from "../config/schema.js";
 import type { CommandArgs, CommandCtx } from "./types.js";
@@ -29,7 +30,7 @@ export type InitContext = CommandCtx;
  * Initialize a new catalog.
  *
  * - Without flags: scans installed packages and generates a catalog with
- *   `rating: 'core'` for every discovered package.
+ *   every discovered package enabled.
  * - With `--from-gist=<id>`: fetches the gist, reads its `cat.yaml` file,
  *   validates it, and writes it as the local catalog.
  */
@@ -70,7 +71,6 @@ function initFromScan(ctx: InitContext): void {
   for (const [name, pkg] of Object.entries(installed)) {
     packages[name] = {
       source: pkg.source,
-      rating: "core",
     };
   }
 
@@ -115,6 +115,7 @@ async function initFromGist(gistId: string, ctx: InitContext): Promise<void> {
 
   // Validate and write
   const parsed = yaml.load(gistContent);
+  migrateRatingToEnabledRaw(parsed);
   const catalog = CatalogYamlSchema.parse(parsed);
 
   writeCatalog(catalog, ctx.home);

package/src/commands/remove.ts

@@ -12,6 +12,7 @@
 
 import type { CommandArgs, CommandCtx } from "./types.js";
 import { removePackage } from "../catalog/crud.js";
+import { isPiStefSource } from "../catalog/packages.js";
 import { readCatalog, writeCatalog, readLock, writeLock } from "../config/io.js";
 import { piUninstall } from "../util/exec.js";
 
@@ -41,6 +42,79 @@ export async function removeCommand(
   ctx: RemoveCtx,
 ): Promise<void> {
   const { positional, flags } = args;
+
+  // --- Handle --scope batch mode ---------------------------------------------
+  if ("scope" in flags) {
+    const scope = flags["scope"];
+    if (scope !== "@pi-stef") {
+      ctx.ui.notify(`Unsupported scope: "${scope}". Use --scope @pi-stef.`, "error");
+      return;
+    }
+
+    const catalog = readCatalog(ctx.home);
+    const lock = readLock(ctx.home);
+
+    // isPiStefSource returns false for @pi-stef/catalog by design (see packages.ts)
+    const piStefNames = Object.keys(catalog.packages).filter(
+      (name) => isPiStefSource(catalog.packages[name].source),
+    );
+
+    if (piStefNames.length === 0) {
+      ctx.ui.notify("No @pi-stef packages found in catalog", "info");
+      return;
+    }
+
+    // Confirmation
+    const skipConfirm = "yes" in flags || "y" in flags;
+    if (!skipConfirm && ctx.ui.confirm) {
+      const confirmed = await ctx.ui.confirm(
+        `Remove ${piStefNames.length} @pi-stef packages from catalog?`,
+      );
+      if (!confirmed) {
+        ctx.ui.notify("Removal cancelled", "info");
+        return;
+      }
+    }
+
+    // Capture sources before removing
+    const sources: Record<string, string> = {};
+    for (const name of piStefNames) {
+      sources[name] = catalog.packages[name].source;
+    }
+
+    // Remove all from catalog and lock file
+    for (const name of piStefNames) {
+      delete catalog.packages[name];
+      if (lock.packages[name]) {
+        delete lock.packages[name];
+      }
+    }
+
+    writeCatalog(catalog, ctx.home);
+    writeLock(lock, ctx.home);
+
+    // Uninstall all
+    let uninstalled = 0;
+    let failed = 0;
+    for (const name of piStefNames) {
+      ctx.ui.setWorkingMessage?.(`Uninstalling ${name} (${uninstalled + 1}/${piStefNames.length})...`);
+      try {
+        await piUninstall(sources[name]);
+        uninstalled++;
+      } catch {
+        ctx.ui.notify(`Warning: uninstall of "${name}" failed`, "warning");
+        failed++;
+      }
+    }
+    ctx.ui.setWorkingMessage?.();
+
+    ctx.ui.notify(
+      `Scope @pi-stef: removed ${piStefNames.length}, uninstalled ${uninstalled}${failed > 0 ? ` (${failed} uninstall failed)` : ""}`,
+      failed > 0 ? "warning" : "info",
+    );
+    return;
+  }
+
   const name = positional[0];
 
   // --- Validate required args -----------------------------------------------
@@ -91,6 +165,7 @@ export async function removeCommand(
   ctx.ui.notify(`Removed "${name}" from catalog`, "info");
 
   // --- Run pi uninstall -----------------------------------------------------
+  ctx.ui.setWorkingMessage?.(`Uninstalling ${name}...`);
   try {
     await piUninstall(source);
   } catch {
@@ -99,4 +174,5 @@ export async function removeCommand(
       "warning",
     );
   }
+  ctx.ui.setWorkingMessage?.();
 }

package/src/commands/reset.ts

@@ -0,0 +1,136 @@
+/**
+ * `ct reset` subcommand implementation.
+ *
+ * Full nuke: uninstalls all @pi-stef packages, deletes gist refs,
+ * deletes config files (cat.yaml, catalog.lock.json, .gist),
+ * and removes the empty catalog directory.
+ *
+ * Usage:
+ *   - `ct reset` — prompts for confirmation
+ *   - `ct reset --yes` — skips confirmation
+ *
+ * This is a destructive operation. The catalog can be re-initialized
+ * with `ct init` after resetting.
+ */
+
+import fs from "node:fs";
+import type { CommandArgs, CommandCtx } from "./types.js";
+import { isPiStefSource } from "../catalog/packages.js";
+import { catalogDir, catalogFile, lockFile } from "../config/paths.js";
+import { piUninstall } from "../util/exec.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Context for `resetCommand`, extending the base with `confirm`. */
+export interface ResetCtx extends CommandCtx {
+  ui: CommandCtx["ui"] & {
+    confirm?: (message: string) => Promise<boolean>;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// resetCommand
+// ---------------------------------------------------------------------------
+
+/**
+ * Execute the `ct reset` subcommand.
+ *
+ * 1. Check cat.yaml exists
+ * 2. Confirm (skippable with --yes)
+ * 3. Find @pi-stef packages (isPiStefSource excludes catalog)
+ * 4. pi uninstall each
+ * 5. Delete config files with fs.rmSync({ recursive: true, force: true })
+ * 6. Remove empty catalog directory
+ */
+export async function resetCommand(
+  args: CommandArgs,
+  ctx: ResetCtx,
+): Promise<void> {
+  const { flags } = args;
+
+  // --- Check cat.yaml exists ------------------------------------------------
+  const catPath = catalogFile(ctx.home);
+  if (!fs.existsSync(catPath)) {
+    ctx.ui.notify("No catalog found. Run `ct init` first.", "error");
+    return;
+  }
+
+  // --- Confirmation ----------------------------------------------------------
+  const skipConfirm = "yes" in flags || "y" in flags;
+  if (!skipConfirm && ctx.ui.confirm) {
+    const confirmed = await ctx.ui.confirm(
+      "This will uninstall all @pi-stef packages and delete all catalog config. Continue?",
+    );
+    if (!confirmed) {
+      ctx.ui.notify("Reset cancelled", "info");
+      return;
+    }
+  }
+
+  // --- Find @pi-stef packages -----------------------------------------------
+  // Read catalog directly (raw YAML) to avoid schema validation on corrupt files
+  let packages: Record<string, { source: string }> = {};
+  try {
+    const yaml = await import("js-yaml");
+    const content = fs.readFileSync(catPath, "utf8");
+    const parsed = yaml.load(content) as { packages?: Record<string, { source: string }> };
+    packages = parsed?.packages ?? {};
+  } catch {
+    // If YAML is corrupt, we still want to delete config files
+    ctx.ui.notify("Warning: could not parse cat.yaml — skipping uninstall step", "warning");
+  }
+
+  const piStefNames = Object.keys(packages).filter(
+    (name) => isPiStefSource(packages[name].source),
+  );
+
+  // --- Uninstall @pi-stef packages ------------------------------------------
+  let uninstalled = 0;
+  let failed = 0;
+
+  for (const name of piStefNames) {
+    ctx.ui.setWorkingMessage?.(`Uninstalling ${name} (${uninstalled + 1}/${piStefNames.length})...`);
+    try {
+      await piUninstall(packages[name].source);
+      uninstalled++;
+    } catch {
+      ctx.ui.notify(`Warning: uninstall of "${name}" failed`, "warning");
+      failed++;
+    }
+  }
+  ctx.ui.setWorkingMessage?.();
+
+  // --- Delete config files --------------------------------------------------
+  const dir = catalogDir(ctx.home);
+  const gistPath = `${dir}/.gist`;
+
+  // Delete individual files first, then the directory
+  for (const filePath of [catPath, lockFile(ctx.home), gistPath]) {
+    try {
+      fs.rmSync(filePath, { force: true });
+    } catch {
+      // Ignore errors — file may not exist
+    }
+  }
+
+  // Remove the catalog directory itself
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // Ignore errors — directory may not exist or be non-empty
+  }
+
+  // --- Report ----------------------------------------------------------------
+  const parts: string[] = [];
+  if (piStefNames.length > 0) {
+    parts.push(`uninstalled ${uninstalled}/${piStefNames.length} packages`);
+  }
+  parts.push("deleted config files");
+
+  ctx.ui.notify(
+    `Reset complete: ${parts.join(", ")}${failed > 0 ? ` (${failed} uninstall failed)` : ""}`,
+    failed > 0 ? "warning" : "info",
+  );
+}

package/src/commands/status.ts

@@ -1,14 +1,16 @@
 /**
  * `ct status` subcommand implementation.
  *
- * Shows catalog status: profile, package counts by rating,
- * installed/missing/orphan counts, gist URL, and last sync time.
+ * Shows catalog status: profile, package counts (enabled/disabled),
+ * installed/missing/orphan counts, gist URL, last sync time,
+ * and individual package listing with setup status.
  */
 
 import type { CommandArgs, CommandCtx } from "./types.js";
 import { readCatalog, readLock } from "../config/io.js";
 import { scanInstalled } from "../catalog/install.js";
 import { readCachedGistId } from "../sync/cache.js";
+import { checkSetupForSource } from "../catalog/setup.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -17,30 +19,6 @@ import { readCachedGistId } from "../sync/cache.js";
 /** Context for `statusCommand`. Uses the base `CommandCtx`. */
 export type StatusCtx = CommandCtx;
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-interface RatingCounts {
-  core: number;
-  useful: number;
-  debatable: number;
-  disabled: number;
-}
-
-function countByRating(
-  packages: Record<string, { rating: string; enabled?: boolean }>,
-): RatingCounts {
-  const counts: RatingCounts = { core: 0, useful: 0, debatable: 0, disabled: 0 };
-  for (const pkg of Object.values(packages)) {
-    const r = pkg.rating as keyof RatingCounts;
-    if (r in counts) {
-      counts[r]++;
-    }
-  }
-  return counts;
-}
-
 // ---------------------------------------------------------------------------
 // statusCommand
 // ---------------------------------------------------------------------------
@@ -49,7 +27,7 @@ function countByRating(
  * Execute the `ct status` subcommand.
  *
  * Reads catalog, lock, gist cache, and installed packages to build
- * a comprehensive status summary.
+ * a comprehensive status summary with individual package listing.
  */
 export async function statusCommand(
   args: CommandArgs,
@@ -67,24 +45,33 @@ export async function statusCommand(
   const packages = catalog.packages;
   const totalPackages = Object.keys(packages).length;
 
-  // --- Package counts by rating ---
-  const ratingCounts = countByRating(packages);
+  // --- Enabled / disabled counts ---
+  let enabledCount = 0;
+  let disabledCount = 0;
+  for (const pkg of Object.values(packages)) {
+    if (pkg.enabled === false) {
+      disabledCount++;
+    } else {
+      enabledCount++;
+    }
+  }
 
   // --- Installed / missing / orphan ---
+  // Build a lookup map for installed packages by source
+  const installedBySource = new Map<string, { name: string; version?: string }>();
+  for (const inst of Object.values(installed)) {
+    installedBySource.set(inst.source, { name: inst.name, version: inst.version });
+  }
+
   const catalogSources = new Set<string>();
   for (const pkg of Object.values(packages)) {
     catalogSources.add(pkg.source);
   }
 
-  const installedSources = new Set<string>();
-  for (const inst of Object.values(installed)) {
-    installedSources.add(inst.source);
-  }
-
   // Count how many catalog packages are actually installed
   let installedCount = 0;
   for (const pkg of Object.values(packages)) {
-    if (installedSources.has(pkg.source)) {
+    if (installedBySource.has(pkg.source)) {
       installedCount++;
     }
   }
@@ -116,7 +103,7 @@ export async function statusCommand(
 
   // Package counts
   lines.push(
-    `Packages: ${totalPackages} total (core: ${ratingCounts.core}, useful: ${ratingCounts.useful}, debatable: ${ratingCounts.debatable}, disabled: ${ratingCounts.disabled})`,
+    `Packages: ${totalPackages} total (${enabledCount} enabled, ${disabledCount} disabled)`,
   );
 
   // Installed/missing/orphan
@@ -138,5 +125,53 @@ export async function statusCommand(
     lines.push("Last sync: never synced");
   }
 
+  // --- Individual package listing ---
+  if (totalPackages > 0) {
+    lines.push("");
+    lines.push("Packages:");
+
+    for (const [name, pkg] of Object.entries(packages)) {
+      const isDisabled = pkg.enabled === false;
+      const isInstalled = installedBySource.has(pkg.source);
+      const inst = installedBySource.get(pkg.source);
+
+      // Status indicator
+      let status: string;
+      if (isDisabled) {
+        status = "disabled";
+      } else if (isInstalled) {
+        status = "installed";
+      } else {
+        status = "missing";
+      }
+
+      // Version info
+      const versionStr = inst?.version ? ` v${inst.version}` : "";
+
+      // Setup status
+      let setupStr = "";
+      if (isInstalled && !isDisabled) {
+        const setup = checkSetupForSource(pkg.source, ctx.home);
+        if (setup && !setup.ok) {
+          setupStr = " ⚠ setup incomplete";
+        }
+      }
+
+      lines.push(`  ${name} [${status}]${versionStr}${setupStr}`);
+    }
+  }
+
+  // --- Orphans ---
+  if (orphanCount > 0) {
+    lines.push("");
+    lines.push("Orphans:");
+    for (const inst of Object.values(installed)) {
+      if (!catalogSources.has(inst.source)) {
+        const versionStr = inst.version ? ` v${inst.version}` : "";
+        lines.push(`  ${inst.name} [orphan]${versionStr}`);
+      }
+    }
+  }
+
   ctx.ui.notify(lines.join("\n"), "info");
 }