supipowers 1.5.3 → 2.0.0

package/src/commands/generate.ts

@@ -1,5 +1,5 @@
 import type { Platform } from "../platform/types.js";
-import type { DriftCheckResult } from "../types.js";
+import type { DriftCheckResult, WorkspaceTarget } from "../types.js";
 import { notifyInfo, notifyError, notifyWarning } from "../notifications/renderer.js";
 import {
   loadState,
@@ -7,7 +7,19 @@ import {
   discoverDocFiles,
   getHeadCommit,
   checkDocDrift,
+  type DocDriftScope,
 } from "../docs/drift.js";
+import {
+  buildWorkspaceTargetOptionLabel,
+  parseTargetArg,
+  selectWorkspaceTarget,
+  stripCliArg,
+  tokenizeCliArgs,
+  type WorkspaceTargetOption,
+} from "../workspace/selector.js";
+import { detectPackageManager } from "../workspace/package-manager.js";
+import { resolveRepoRoot } from "../workspace/repo-root.js";
+import { discoverWorkspaceTargets } from "../workspace/targets.js";
 
 // ── Multi-select UI ───────────────────────────────────────────
 
@@ -47,44 +59,109 @@ async function selectDocFiles(
   return [...selected];
 }
 
+
+function parseGenerateSubcommand(args?: string): string {
+  return tokenizeCliArgs(stripCliArg(args, "--target"))[0] ?? "docs";
+}
+
+function formatGenerateTarget(target: WorkspaceTarget): string {
+  return target.kind === "root"
+    ? `${target.name} (root · ${target.relativeDir})`
+    : `${target.name} (${target.relativeDir})`;
+}
+
+function buildGenerateTargetOptionLabel(option: WorkspaceTargetOption<WorkspaceTarget>): string {
+  return option.target.kind === "root"
+    ? buildWorkspaceTargetOptionLabel(option, ["root docs"])
+    : buildWorkspaceTargetOptionLabel(option, ["package docs"]);
+}
+
+async function resolveGenerateScope(
+  platform: Platform,
+  ctx: any,
+  args?: string,
+ ): Promise<DocDriftScope | null> {
+  const requestedTarget = parseTargetArg(args);
+  const repoRoot = await resolveRepoRoot(platform, ctx.cwd);
+  const packageManager = detectPackageManager(repoRoot);
+  const targets = discoverWorkspaceTargets(repoRoot, packageManager);
+  if (targets.length === 0) {
+    notifyError(ctx, "No documentation targets found", "Create a package.json with name and version before running /supi:generate.");
+    return null;
+  }
+
+  const selectedTarget = await selectWorkspaceTarget(
+    ctx,
+    targets.map((target) => ({
+      target,
+      changed: false,
+      label: buildGenerateTargetOptionLabel({ target, changed: false }),
+    })),
+    requestedTarget,
+    {
+      title: "Documentation target",
+      helpText: "Pick the package whose documentation should be checked. Root selects only repository-level docs.",
+    },
+  );
+
+  if (requestedTarget && !selectedTarget) {
+    notifyError(ctx, "Documentation target not found", requestedTarget);
+    return null;
+  }
+
+  if (!selectedTarget) {
+    return null;
+  }
+
+  return { target: selectedTarget, allTargets: targets };
+}
+
 // ── Subcommand: docs ──────────────────────────────────────────
 
-async function handleDocs(platform: Platform, ctx: any): Promise<void> {
+async function handleDocs(platform: Platform, ctx: any, args?: string): Promise<void> {
   if (!ctx.hasUI) {
     notifyWarning(ctx, "Doc drift check requires interactive mode");
     return;
   }
 
+  const scope = await resolveGenerateScope(platform, ctx, args);
+  if (!scope) {
+    return;
+  }
+
   const cwd = ctx.cwd;
   const { paths } = platform;
-  const state = loadState(paths, cwd);
+  const targetSummary = formatGenerateTarget(scope.target);
+  const state = loadState(paths, cwd, scope);
 
   // First run: discover and select files, then steer main thread for full audit
   if (state.trackedFiles.length === 0) {
-    const discovered = await discoverDocFiles(platform, cwd);
+    const discovered = await discoverDocFiles(platform, cwd, scope);
     if (discovered.length === 0) {
-      notifyWarning(ctx, "No documentation files found in this repository");
+      notifyWarning(ctx, "No documentation files found for selected target", `Target: ${targetSummary}`);
       return;
     }
 
     const selected = await selectDocFiles(ctx, discovered);
     if (selected.length === 0) {
-      notifyInfo(ctx, "No files selected \u2014 doc tracking not set up");
+      notifyInfo(ctx, "No files selected — doc tracking not set up", `Target: ${targetSummary}`);
       return;
     }
 
-    // Persist tracked files but leave lastCommit null \u2014 updated after fix starts
+    // Persist tracked files but leave lastCommit null — updated after fix starts
     saveState(paths, cwd, {
       trackedFiles: selected,
       lastCommit: null,
       lastRunAt: new Date().toISOString(),
-    });
+    }, scope.target);
 
     // Steer the main thread to audit and fix docs directly
     const docList = selected.map((f) => `- \`${f}\``).join("\n");
     const prompt = [
       `Check these documentation files for accuracy against the current codebase:`,
       ``,
+      `Target: ${targetSummary}`,
+      ``,
       docList,
       ``,
       `<critical>`,
@@ -96,15 +173,16 @@ async function handleDocs(platform: Platform, ctx: any): Promise<void> {
       `2. **Missing documentation**: new commands, features, config options that exist in code but not in docs`,
       `3. **Structural gaps**: important sections that should exist based on the codebase but don't`,
       ``,
-      `For each issue found, fix it directly in the documentation file. Do NOT output JSON or a report \u2014 just fix the files.`,
+      `For each issue found, fix it directly in the documentation file. Do NOT output JSON or a report — just fix the files.`,
       `If documentation is accurate, say so and make no changes.`,
       ``,
       `Rules:`,
       `- Only fix factual inaccuracies and add missing sections for undocumented features`,
       `- Do NOT rewrite prose, improve wording, or restructure existing content`,
       `- Preserve each document's existing formatting, tone, and conventions`,
+      `- Limit the review to the selected target`,
     ].join("\n");
-    notifyInfo(ctx, "Starting full documentation audit", `${selected.length} file(s) selected`);
+    notifyInfo(ctx, "Starting full documentation audit", `${selected.length} file(s) selected · Target: ${targetSummary}`);
 
     platform.sendMessage(
       {
@@ -118,21 +196,30 @@ async function handleDocs(platform: Platform, ctx: any): Promise<void> {
   }
 
   // Subsequent run: headless sub-agent drift check
-  const result = await checkDocDrift(platform, cwd);
+  const result = await checkDocDrift(platform, cwd, scope);
+
+  if (result?.errors && result.errors.length > 0) {
+    notifyError(
+      ctx,
+      "Doc drift check failed",
+      `${result.errors.length} sub-agent(s) could not produce valid output. Target: ${targetSummary}\n\n- ${result.errors.join("\n- ")}`,
+    );
+    return;
+  }
 
   if (!result || !result.drifted) {
-    notifyInfo(ctx, "Docs are up to date", result?.summary ?? "No changes since last check");
+    notifyInfo(ctx, "Docs are up to date", `${result?.summary ?? "No changes since last check"} · Target: ${targetSummary}`);
     return;
   }
 
   // Build lightweight steer summary from findings
-  const steer = buildSteerSummary(result);
-  notifyInfo(ctx, "Documentation drift detected", `${result.findings.length} finding(s)`);
+  const steer = buildSteerSummary(result, targetSummary);
+  notifyInfo(ctx, "Documentation drift detected", `${result.findings.length} finding(s) · Target: ${targetSummary}`);
 
-  // Update state only now \u2014 user has seen findings and we\u2019re about to fix.
+  // Update state only now — user has seen findings and we’re about to fix.
   const head = await getHeadCommit(platform, cwd);
-  const currentState = loadState(paths, cwd);
-  saveState(paths, cwd, { ...currentState, lastCommit: head, lastRunAt: new Date().toISOString() });
+  const currentState = loadState(paths, cwd, scope);
+  saveState(paths, cwd, { ...currentState, lastCommit: head, lastRunAt: new Date().toISOString() }, scope.target);
 
   platform.sendMessage(
     {
@@ -144,8 +231,11 @@ async function handleDocs(platform: Platform, ctx: any): Promise<void> {
   );
 }
 
-function buildSteerSummary(result: DriftCheckResult): string {
-  const lines: string[] = ["Documentation drift detected. Please fix the following issues:", ""];
+function buildSteerSummary(result: DriftCheckResult, targetSummary: string): string {
+  const lines: string[] = [
+    `Documentation drift detected for target ${targetSummary}. Please fix the following issues:`,
+    "",
+  ];
 
   const byFile = new Map<string, typeof result.findings>();
   for (const f of result.findings) {
@@ -182,11 +272,11 @@ export function registerGenerateCommand(platform: Platform): void {
       return matches.length > 0 ? matches : null;
     },
     async handler(args: string | undefined, ctx: any) {
-      const subcommand = args?.trim().split(/\s+/)[0] ?? "docs";
+      const subcommand = parseGenerateSubcommand(args);
 
       switch (subcommand) {
         case "docs":
-          await handleDocs(platform, ctx);
+          await handleDocs(platform, ctx, args);
           break;
         default:
           notifyError(

package/src/commands/memory.ts

@@ -0,0 +1,192 @@
+import type { Platform, PlatformContext } from "../platform/types.js";
+import { loadConfig } from "../config/loader.js";
+import {
+  checkMempalaceProjectInitialized,
+  runMempalaceSetup,
+  snapshotMempalaceInstall,
+  steerMempalaceInitialization,
+} from "../mempalace/installer-helper.js";
+
+const SUBCOMMANDS = [
+  { name: "status", description: "Show palace path, managed venv, and install status" },
+  { name: "setup", description: "Install or repair the managed Python environment and MemPalace package" },
+] as const;
+
+const HELP = [
+  "/supi:memory — native MemPalace integration",
+  "",
+  "Subcommands:",
+  ...SUBCOMMANDS.map((subcommand) => `  ${subcommand.name.padEnd(8)} ${subcommand.description}`),
+  "",
+  "Memory APIs are exposed to the agent via the `mempalace` tool.",
+].join("\n");
+
+function statusReport(platform: Platform, cwd: string): string {
+  const config = loadConfig(platform.paths, cwd);
+  const snap = snapshotMempalaceInstall(platform.paths, cwd, config);
+  const lines = [
+    "/supi:memory status",
+    "",
+    `enabled: ${snap.enabled}`,
+    `palace path: ${config.mempalace.palacePath}`,
+    `default wing strategy: ${config.mempalace.defaultWingStrategy}`,
+    `managed venv: ${snap.venvPath}`,
+    `managed python: ${snap.venvPython} (${snap.venvInstalled ? "present" : "missing"})`,
+    `managed uv: ${snap.uvPath} (${snap.uvInstalled ? "present" : "missing"})`,
+    `bridge script: ${snap.bridgeOk ? snap.bridgePath : `${snap.bridgePath} (missing)`}`,
+    `package version: ${snap.packageVersion}`,
+    "",
+    snap.ready
+      ? "Run `/supi:memory setup` again to upgrade or repair the managed environment."
+      : "Run `/supi:memory setup` to install the managed environment.",
+  ];
+  return lines.join("\n");
+}
+
+async function runSetup(platform: Platform, ctx: PlatformContext): Promise<void> {
+  const config = loadConfig(platform.paths, ctx.cwd);
+  if (!config.mempalace.enabled) {
+    ctx.ui.notify("MemPalace integration is disabled in config (mempalace.enabled=false). Enable it before running setup.", "warning");
+    return;
+  }
+
+  const snap = snapshotMempalaceInstall(platform.paths, ctx.cwd, config);
+  if (!snap.bridgeOk) {
+    ctx.ui.notify(`MemPalace bridge missing at ${snap.bridgePath}. Reinstall supipowers and retry.`, "error");
+    return;
+  }
+
+  ctx.ui.notify(
+    [
+      "/supi:memory setup",
+      "",
+      `palace path:   ${config.mempalace.palacePath}`,
+      `managed venv:  ${config.mempalace.managedVenvPath}`,
+      `package:       mempalace==${snap.packageVersion} (PyPI)`,
+      "",
+      "This may take a minute on first install while ChromaDB and native deps are built.",
+    ].join("\n"),
+    "info",
+  );
+
+  const exec = async (command: string, args: string[], options?: { input?: string; timeoutMs?: number }) => {
+    const result = await platform.exec(command, args, {
+      cwd: ctx.cwd,
+      ...(options?.timeoutMs ? { timeout: options.timeoutMs } : {}),
+    });
+    return { code: result.code, stdout: result.stdout, stderr: result.stderr };
+  };
+
+  const result = await runMempalaceSetup({
+    paths: platform.paths,
+    cwd: ctx.cwd,
+    config,
+    runner: exec,
+    onProgress: (message) => ctx.ui.notify(`MemPalace setup: ${message}`, "info"),
+  });
+
+  if (!result.ok) {
+    const stderr = result.stderrTail ? `\n\n${result.stderrTail}` : "";
+    ctx.ui.notify(
+      `MemPalace setup failed (${result.error.code}): ${result.error.message}\n${result.error.remediation ?? ""}${stderr}`.trim(),
+      "error",
+    );
+    return;
+  }
+
+  ctx.ui.notify(
+    [
+      "MemPalace setup complete.",
+      `uv:      ${result.details.uvPath} (${result.details.uvVersion})`,
+      `python:  ${result.details.managedPython} (managed by uv)`,
+      `venv:    ${result.details.venvPath}`,
+      `package: mempalace==${result.details.packageVersion}`,
+    ].join("\n"),
+    "info",
+  );
+
+  // Check if the current project's wing is already initialized; if not, steer
+  // the model to run init + mine through the mempalace tool.
+  const initState = await checkMempalaceProjectInitialized({
+    paths: platform.paths,
+    cwd: ctx.cwd,
+    config,
+  });
+
+  if (initState.initialized) {
+    ctx.ui.notify(
+      `MemPalace project wing \`${initState.wing}\` is already initialized.`,
+      "info",
+    );
+    return;
+  }
+
+  const steered = steerMempalaceInitialization(platform, {
+    wing: initState.wing,
+    cwd: ctx.cwd,
+  });
+  if (steered) {
+    ctx.ui.notify(
+      `Steering the agent to initialize project wing \`${initState.wing}\` (running mempalace init + mine).`,
+      "info",
+    );
+  } else {
+    ctx.ui.notify(
+      `Project wing \`${initState.wing}\` not initialized. Ask the agent to run mempalace(action="init", dir=".", yes=true).`,
+      "warning",
+    );
+  }
+}
+
+export function handleMemory(platform: Platform, ctx: PlatformContext, args?: string): void {
+  if (!ctx.hasUI) return;
+
+  const sub = (args ?? "").trim().split(/\s+/)[0] ?? "";
+
+  if (sub === "" || sub === "help" || sub === "--help" || sub === "-h") {
+    ctx.ui.notify(HELP, "info");
+    return;
+  }
+
+  if (sub === "status") {
+    try {
+      ctx.ui.notify(statusReport(platform, ctx.cwd), "info");
+    } catch (err) {
+      ctx.ui.notify(`MemPalace status failed: ${(err as Error).message}`, "error");
+    }
+    return;
+  }
+
+  if (sub === "setup") {
+    void (async () => {
+      try {
+        await runSetup(platform, ctx);
+      } catch (err) {
+        ctx.ui.notify(`MemPalace setup crashed: ${(err as Error).message}`, "error");
+      }
+    })();
+    return;
+  }
+
+  ctx.ui.notify(`Unknown /supi:memory subcommand: ${sub}\n\n${HELP}`, "warning");
+}
+
+export function registerMemoryCommand(platform: Platform): void {
+  platform.registerCommand("supi:memory", {
+    description: "Manage native MemPalace integration (status, setup)",
+    getArgumentCompletions(prefix: string) {
+      const lower = prefix.trim().toLowerCase();
+      const matches = SUBCOMMANDS
+        .filter((subcommand) => subcommand.name.startsWith(lower))
+        .map((subcommand) => ({
+          value: `${subcommand.name} `,
+          label: subcommand.name,
+          description: subcommand.description,
+        }));
+      return matches.length > 0 ? matches : null;
+    },
+    async handler(args: string | undefined, ctx: any) {
+      handleMemory(platform, ctx, args);
+    },
+  });
+}

package/src/commands/model-picker.ts

@@ -33,10 +33,9 @@ import {
 const ALL_TAB = "ALL";
 const MAX_VISIBLE = 12;
 
-/** Set of available (authenticated) providers and model IDs, from ctx.modelRegistry */
+/** Available (authenticated) models sourced directly from ctx.modelRegistry.getAvailable() */
 export interface AvailableModelSet {
-  providers: Set<string>;
-  modelIds: Set<string>;
+  models: Array<{ provider: string; id: string }>;
 }
 
 interface ModelItem {
@@ -48,45 +47,53 @@ interface ModelItem {
 
 
 /**
- * Build the flat model list from bundled providers.
- * @param available — if provided, marks models whose provider has auth
+ * Build the flat model list.
+ * When registry models are provided, uses them as source of truth (all authenticated).
+ * Falls back to the bundled static list when no registry data is available.
  */
 function loadAllModels(available?: AvailableModelSet): { items: ModelItem[]; configuredProviders: Set<string> } {
-  const providers = getBundledProviders();
   const items: ModelItem[] = [];
   const configuredProviders = new Set<string>();
 
-  for (const provider of providers) {
-    const name = String(provider);
-    const configured = available ? available.providers.has(name) : true;
-    if (configured) configuredProviders.add(name);
-
-    const models = getBundledModels(provider as GeneratedProvider);
-    for (const m of models) {
+  if (available && available.models.length > 0) {
+    // Registry-sourced: all returned models are authenticated — use them directly
+    for (const m of available.models) {
+      configuredProviders.add(m.provider);
       items.push({
-        provider: name,
+        provider: m.provider,
         id: m.id,
-        displayLabel: `${name}/${m.id}`,
-        configured,
+        displayLabel: `${m.provider}/${m.id}`,
+        configured: true,
       });
     }
+  } else {
+    // Fallback: bundled static list (no registry data available)
+    for (const provider of getBundledProviders()) {
+      const name = String(provider);
+      const models = getBundledModels(provider as GeneratedProvider);
+      for (const m of models) {
+        items.push({
+          provider: name,
+          id: m.id,
+          displayLabel: `${name}/${m.id}`,
+          configured: true,
+        });
+      }
+    }
   }
 
-  // Sort like OMP's native /model: provider → version desc → -latest first → date desc → alpha
+  // Sort: provider asc → version desc → -latest first → date desc → alpha
   const dateRe = /-(\d{8})$/;
   const latestRe = /-latest$/;
 
   items.sort((a, b) => {
-    // Group by provider
     const provCmp = a.provider.localeCompare(b.provider);
     if (provCmp !== 0) return provCmp;
 
-    // Version number descending (higher = newer model)
     const aVer = extractVersionNumber(a.id);
     const bVer = extractVersionNumber(b.id);
     if (aVer !== bVer) return bVer - aVer;
 
-    // Recency: models with -latest or YYYYMMDD suffix come first
     const aIsLatest = latestRe.test(a.id);
     const bIsLatest = latestRe.test(b.id);
     const aDate = a.id.match(dateRe)?.[1] ?? "";
@@ -96,7 +103,7 @@ function loadAllModels(available?: AvailableModelSet): { items: ModelItem[]; con
 
     if (aHasRecency !== bHasRecency) return aHasRecency ? -1 : 1;
     if (aIsLatest !== bIsLatest) return aIsLatest ? -1 : 1;
-    if (aDate && bDate) return bDate.localeCompare(aDate); // newest first
+    if (aDate && bDate) return bDate.localeCompare(aDate);
 
     return a.id.localeCompare(b.id);
   });

package/src/commands/model.ts

@@ -194,12 +194,11 @@ export async function selectModelFromList(
       const models = ctx.modelRegistry?.getAvailable?.() ?? [];
       if (models.length > 0) {
         available = {
-          providers: new Set(models.map((m: any) => String(m.provider))),
-          modelIds: new Set(models.map((m: any) => `${m.provider}/${m.id}`)),
+          models: models.map((m: any) => ({ provider: String(m.provider), id: m.id })),
         };
       }
     } catch {
-      // Fall through — picker will show all models unfiltered
+      // Fall through — picker will show bundled list unfiltered
     }
     return ctx.ui.custom((tui: any, theme: any, kb: any, done: any) =>
       createModelPicker(tui, theme, kb, done, available),
@@ -207,12 +206,23 @@ export async function selectModelFromList(
   }
 
   // Fallback: flat select list for non-OMP platforms
-  const providers = getBundledProviders();
+  // Prefer live registry models; fall back to bundled list when unavailable
   const allModels: string[] = [];
-  for (const provider of providers.sort()) {
-    const models = getBundledModels(provider as GeneratedProvider);
-    for (const m of models) {
-      allModels.push(`${provider}/${m.id}`);
+  try {
+    const registryModels = ctx.modelRegistry?.getAvailable?.() ?? [];
+    for (const m of registryModels) {
+      allModels.push(`${m.provider}/${m.id}`);
+    }
+  } catch {
+    // ignore
+  }
+  if (allModels.length === 0) {
+    const providers = getBundledProviders();
+    for (const provider of providers.sort()) {
+      const models = getBundledModels(provider as GeneratedProvider);
+      for (const m of models) {
+        allModels.push(`${provider}/${m.id}`);
+      }
     }
   }
   allModels.sort();