supipowers 1.5.3 → 2.0.1

package/src/commands/config.ts

@@ -1,16 +1,21 @@
+import { isDeepStrictEqual } from "node:util";
 import type { Platform, PlatformContext } from "../platform/types.js";
 import { DEFAULT_CONFIG } from "../config/defaults.js";
-import { formatConfigErrors, inspectConfig, updateConfig } from "../config/loader.js";
+import { formatConfigErrors, inspectConfig, inspectConfigAtScope, updateConfig } from "../config/loader.js";
 import type { InspectionLoadResult } from "../config/schema.js";
-import type { SupipowersConfig } from "../types.js";
+import { validateQualityGates } from "../config/schema.js";
 import { createWorkflowProgress } from "../platform/progress.js";
 import {
-  interactivelySaveGateSetup,
+  formatGateProposal,
   setupGates,
   summarizeEnabledGates,
   type GateSetupMode,
   type SetupGatesProgressEvent,
 } from "../quality/setup.js";
+import type { ConfigScope, QualityGatesConfig, SetupProposal, SupipowersConfig } from "../types.js";
+import { resolvePackageManager } from "../workspace/package-manager.js";
+import { resolveRepoRoot } from "../workspace/repo-root.js";
+import { discoverWorkspaceTargets } from "../workspace/targets.js";
 
 const FRAMEWORK_OPTIONS = [
   { value: "", label: "not set — auto-detect on first /supi:qa run" },
@@ -38,18 +43,29 @@ export interface SettingDef {
   set: (cwd: string, value: unknown) => Promise<string | null>;
 }
 
+export interface ConfigScopeSelection {
+  scope: ConfigScope;
+  repoRoot: string;
+  isMonorepo: boolean;
+}
+
+export interface ConfigScopeView {
+  selection: ConfigScopeSelection;
+  inspection: InspectionLoadResult;
+  globalInspection: InspectionLoadResult;
+  rootInspection: InspectionLoadResult;
+}
+
 export interface ConfigCommandDependencies {
   inspectConfig: typeof inspectConfig;
   updateConfig: typeof updateConfig;
   setupGates: typeof setupGates;
-  interactivelySaveGateSetup: typeof interactivelySaveGateSetup;
 }
 
 const CONFIG_COMMAND_DEPENDENCIES: ConfigCommandDependencies = {
   inspectConfig,
   updateConfig,
   setupGates,
-  interactivelySaveGateSetup,
 };
 
 function currentConfig(inspection: InspectionLoadResult): SupipowersConfig {
@@ -64,6 +80,159 @@ function describeInspection(inspection: InspectionLoadResult, config: Supipowers
   return summarizeEnabledGates(config.quality.gates);
 }
 
+function getConfigResolutionOptions(selection: ConfigScopeSelection): {
+  repoRoot: string;
+} {
+  return { repoRoot: selection.repoRoot };
+}
+
+function getConfigMutationOptions(selection: ConfigScopeSelection): {
+  scope: ConfigScope;
+  repoRoot: string;
+} {
+  return {
+    scope: selection.scope,
+    ...getConfigResolutionOptions(selection),
+  };
+}
+
+function getSelectionCwd(selection: ConfigScopeSelection): string {
+  return selection.repoRoot;
+}
+
+function configPathForSelection(selection: ConfigScopeSelection): string {
+  switch (selection.scope) {
+    case "global":
+      return "~/.omp/supipowers/config.json";
+    case "root":
+      return ".omp/supipowers/config.json";
+  }
+}
+
+function repositoryScopeLabel(selection: ConfigScopeSelection): string {
+  return selection.isMonorepo ? "monorepo repository" : "repository";
+}
+
+function selectionSummary(selection: ConfigScopeSelection): string {
+  return `${selection.scope === "global" ? "global" : repositoryScopeLabel(selection)} — ${configPathForSelection(selection)}`;
+}
+
+function getNestedValue(value: unknown, key: string): unknown {
+  return key
+    .split(".")
+    .reduce<unknown>((current, segment) => {
+      if (!current || typeof current !== "object" || Array.isArray(current)) {
+        return undefined;
+      }
+      return (current as Record<string, unknown>)[segment];
+    }, value);
+}
+
+function getSelectedConfig(view: ConfigScopeView): SupipowersConfig {
+  return currentConfig(view.inspection);
+}
+
+function describeSettingProvenance(view: ConfigScopeView, key: string): string {
+  const defaultValue = getNestedValue(DEFAULT_CONFIG, key);
+  const globalValue = getNestedValue(currentConfig(view.globalInspection), key);
+  const rootValue = getNestedValue(currentConfig(view.rootInspection), key);
+
+  switch (view.selection.scope) {
+    case "global":
+      return isDeepStrictEqual(globalValue, defaultValue) ? "default" : "overridden in global";
+    case "root":
+      if (!isDeepStrictEqual(rootValue, globalValue)) {
+        return "overridden in repository";
+      }
+      if (!isDeepStrictEqual(globalValue, defaultValue)) {
+        return "inherited from global";
+      }
+      return "default";
+  }
+}
+
+function describeSettingValue(display: string, view: ConfigScopeView, key: string): string {
+  return `${display} — ${describeSettingProvenance(view, key)}`;
+}
+
+function parseRevisedQualityGates(raw: string): QualityGatesConfig {
+  const parsed = JSON.parse(raw) as unknown;
+  const validation = validateQualityGates(parsed);
+  if (!validation.valid) {
+    throw new Error(validation.errors.join("\n"));
+  }
+
+  return parsed as QualityGatesConfig;
+}
+
+function buildQualityGateSetupHelpText(
+  proposal: SetupProposal,
+  scopeSelection: ConfigScopeSelection,
+  mode: GateSetupMode,
+): string {
+  const intro = mode === "ai-assisted"
+    ? "AI analyzed your project and suggested these gates."
+    : "Detected project checks and suggested these gates.";
+
+  return [
+    intro,
+    "",
+    formatGateProposal(proposal),
+    "",
+    `Will write to ${configPathForSelection(scopeSelection)}`,
+  ].join("\n");
+}
+
+async function saveQualityGateProposal(
+  ctx: PlatformContext,
+  paths: Platform["paths"],
+  deps: ConfigCommandDependencies,
+  selection: ConfigScopeSelection,
+  proposal: SetupProposal,
+  mode: GateSetupMode,
+): Promise<"saved" | "cancelled"> {
+  let nextProposal = proposal;
+  const selectionCwd = getSelectionCwd(selection);
+  const mutationOptions = getConfigMutationOptions(selection);
+
+  while (true) {
+    const choice = await ctx.ui.select(
+      mode === "ai-assisted" ? "AI-assisted quality gate proposal" : "Quality gate setup",
+      ["Accept", "Revise", "Cancel"],
+      {
+        helpText: buildQualityGateSetupHelpText(nextProposal, selection, mode),
+      },
+    );
+
+    if (!choice || choice === "Cancel") {
+      return "cancelled";
+    }
+
+    if (choice === "Revise") {
+      const revised = await ctx.ui.input(
+        "Edit quality.gates JSON",
+        { value: JSON.stringify(nextProposal.gates, null, 2) },
+      );
+      if (!revised) {
+        continue;
+      }
+
+      try {
+        nextProposal = {
+          ...nextProposal,
+          gates: parseRevisedQualityGates(revised),
+        };
+      } catch (error) {
+        ctx.ui.notify((error as Error).message, "error");
+      }
+      continue;
+    }
+
+    deps.updateConfig(paths, selectionCwd, { quality: { gates: nextProposal.gates } }, mutationOptions);
+    return "saved";
+  }
+}
+
 function createQualityGateSetupProgress(ctx: PlatformContext, mode: GateSetupMode) {
   if (mode !== "ai-assisted") {
     return null;
@@ -109,40 +278,51 @@ function createQualityGateSetupProgress(ctx: PlatformContext, mode: GateSetupMod
   };
 }
 
-function buildGateSetupDialogOptions(mode: GateSetupMode) {
-  return mode === "ai-assisted"
-    ? {
-        title: "AI-assisted quality gate proposal",
-        intro: "AI analyzed your project and suggested these gates.",
-      }
-    : {
-        intro: "Detected project checks and suggested these gates.",
-      };
+export function buildConfigScopeView(
+  platform: Platform,
+  cwd: string,
+  selection: ConfigScopeSelection,
+): ConfigScopeView {
+  const resolutionOptions = getConfigResolutionOptions(selection);
+  const globalInspection = inspectConfigAtScope(platform.paths, cwd, "global", resolutionOptions);
+  const rootInspection = inspectConfigAtScope(platform.paths, cwd, "root", resolutionOptions);
+  const inspection = selection.scope === "global" ? globalInspection : rootInspection;
+
+  return {
+    selection,
+    inspection,
+    globalInspection,
+    rootInspection,
+  };
 }
 
 export function buildSettings(
   platform: Platform,
   ctx: PlatformContext,
-  inspection: InspectionLoadResult,
+  view: ConfigScopeView,
   deps: ConfigCommandDependencies = CONFIG_COMMAND_DEPENDENCIES,
 ): SettingDef[] {
   const { paths } = platform;
-  const config = currentConfig(inspection);
+  const config = getSelectedConfig(view);
+  const selectionCwd = getSelectionCwd(view.selection);
+  const resolutionOptions = getConfigResolutionOptions(view.selection);
+  const mutationOptions = getConfigMutationOptions(view.selection);
 
   return [
     {
       label: "Setup quality gates",
       key: "quality.gates",
-      helpText: "Inspect the project and configure review gates",
+      helpText: `Inspect the project and configure review gates. Changes write to ${configPathForSelection(view.selection)}.`,
       type: "select",
       options: ["Run deterministic setup", "Run AI-assisted setup"],
-      get: () => describeInspection(inspection, config),
-      set: async (cwd, value) => {
+      get: () => describeSettingValue(describeInspection(view.inspection, config), view, "quality.gates"),
+      set: async (_cwd, value) => {
         const mode: GateSetupMode = String(value).includes("AI-assisted") ? "ai-assisted" : "deterministic";
         const progress = createQualityGateSetupProgress(ctx, mode);
 
         try {
-          const result = await deps.setupGates(platform, cwd, deps.inspectConfig(platform.paths, cwd), {
+          const selectedInspection = deps.inspectConfig(paths, selectionCwd, resolutionOptions);
+          const result = await deps.setupGates(platform, selectionCwd, selectedInspection, {
             mode,
             onProgress: (event) => progress?.handle(event),
           });
@@ -157,12 +337,13 @@ export function buildSettings(
           }
 
           progress?.dispose();
-          const saveResult = await deps.interactivelySaveGateSetup(
+          const saveResult = await saveQualityGateProposal(
             ctx,
             paths,
-            cwd,
+            deps,
+            view.selection,
             result.proposal,
-            buildGateSetupDialogOptions(mode),
+            mode,
           );
           return saveResult === "saved" ? "saved" : null;
         } catch (error) {
@@ -176,52 +357,57 @@ export function buildSettings(
     {
       label: "LSP setup guide",
       key: "lsp.setupGuide",
-      helpText: "Show LSP setup tips when no language server is active",
+      helpText: `Show LSP setup tips when no language server is active. Changes write to ${configPathForSelection(view.selection)}.`,
       type: "toggle",
-      get: () => (config.lsp.setupGuide ? "on" : "off"),
-      set: async (cwd, value) => {
-        deps.updateConfig(paths, cwd, { lsp: { setupGuide: value === "on" } });
+      get: () => describeSettingValue(config.lsp.setupGuide ? "on" : "off", view, "lsp.setupGuide"),
+      set: async (_cwd, value) => {
+        deps.updateConfig(paths, selectionCwd, { lsp: { setupGuide: value === "on" } }, mutationOptions);
         return String(value);
       },
     },
     {
       label: "QA framework",
       key: "qa.framework",
-      helpText: "Test runner used by /supi:qa",
+      helpText: `Test runner used by /supi:qa. Changes write to ${configPathForSelection(view.selection)}.`,
       type: "select",
       options: FRAMEWORK_OPTIONS.map((framework) => framework.label),
-      get: () => config.qa.framework ?? "not set",
-      set: async (cwd, value) => {
+      get: () => describeSettingValue(config.qa.framework ?? "not set", view, "qa.framework"),
+      set: async (_cwd, value) => {
         const chosen = FRAMEWORK_OPTIONS.find((framework) => framework.label === value);
         if (!chosen) {
           return null;
         }
 
-        deps.updateConfig(paths, cwd, { qa: { framework: chosen.value || null } });
+        deps.updateConfig(paths, selectionCwd, { qa: { framework: chosen.value || null } }, mutationOptions);
         return chosen.label.split(" — ")[0];
       },
     },
     {
       label: "Release channels",
       key: "release.channels",
-      helpText: "Where /supi:release publishes your project",
+      helpText: `Where /supi:release publishes your project. Changes write to ${configPathForSelection(view.selection)}.`,
       type: "select",
       options: CHANNEL_OPTIONS.map((channel) => channel.label),
-      get: () =>
+      get: () => describeSettingValue(
         config.release.channels.length > 0 ? config.release.channels.join(", ") : "not set",
-      set: async (cwd, value) => {
+        view,
+        "release.channels",
+      ),
+      set: async (_cwd, value) => {
         const chosen = CHANNEL_OPTIONS.find((channel) => channel.label === value);
         if (!chosen) {
           return null;
         }
 
-        deps.updateConfig(paths, cwd, { release: { channels: chosen.value } });
+        deps.updateConfig(paths, selectionCwd, { release: { channels: chosen.value } }, mutationOptions);
         return chosen.label.split(" — ")[0];
       },
     },
   ];
 }
 
+
+
 export async function runConfigMenu(
   platform: Platform,
   ctx: PlatformContext,
@@ -232,16 +418,28 @@ export async function runConfigMenu(
     return;
   }
 
+  const repoRoot = await resolveRepoRoot(platform, ctx.cwd);
+  const isMonorepo = discoverWorkspaceTargets(repoRoot, resolvePackageManager(repoRoot).id)
+    .some((target) => target.kind === "workspace");
+  let selection: ConfigScopeSelection = {
+    scope: "root",
+    repoRoot,
+    isMonorepo,
+  };
+
   while (true) {
-    const inspection = deps.inspectConfig(platform.paths, ctx.cwd);
-    const settings = buildSettings(platform, ctx, inspection, deps);
-    const options = settings.map((setting) => `${setting.label}: ${setting.get()}`);
-    options.push("Done");
+    const view = buildConfigScopeView(platform, ctx.cwd, selection);
+    const settings = buildSettings(platform, ctx, view, deps);
+    const options = [...settings.map((setting) => `${setting.label}: ${setting.get()}`), "Done"];
 
     const choice = await ctx.ui.select(
       "Supipowers Settings",
       options,
-      { helpText: "Select a setting to change · Esc to close" },
+      {
+        helpText: selection.scope === "root" && selection.isMonorepo
+          ? `Editing ${selectionSummary(selection)}. Changes apply to every workspace in this monorepo. Esc to close.`
+          : `Editing ${selectionSummary(selection)}. Changes write to ${configPathForSelection(selection)}. Esc to close.`,
+      },
     );
 
     if (choice === undefined || choice === null || choice === "Done") {
@@ -257,7 +455,7 @@ export async function runConfigMenu(
     try {
       if (setting.type === "select" && setting.options) {
         const currentValue = setting.get();
-        const currentIndex = setting.options.findIndex((option) => option.startsWith(currentValue));
+        const currentIndex = setting.options.findIndex((option) => currentValue.startsWith(option.split(" — ")[0]));
         const value = await ctx.ui.select(
           setting.label,
           setting.options,
@@ -268,15 +466,15 @@ export async function runConfigMenu(
         );
 
         if (value !== undefined && value !== null) {
-          const display = await setting.set(ctx.cwd, value);
+          const display = await setting.set(getSelectionCwd(selection), value);
           if (display) {
             ctx.ui.notify(`${setting.label} → ${display}`, "info");
           }
         }
       } else if (setting.type === "toggle") {
         const current = setting.get();
-        const newValue = current === "on" ? "off" : "on";
-        const display = await setting.set(ctx.cwd, newValue);
+        const newValue = current.startsWith("on") ? "off" : "on";
+        const display = await setting.set(getSelectionCwd(selection), newValue);
         if (display) {
           ctx.ui.notify(`${setting.label} → ${display}`, "info");
         }

package/src/commands/context.ts

@@ -1,7 +1,8 @@
 import { writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { tmpdir } from "node:os";
 import type { Platform, PlatformContext } from "../platform/types.js";
+import { systemPromptText } from "../platform/system-prompt.js";
 import {
   parseSystemPrompt,
   buildBreakdownItems,
@@ -9,6 +10,14 @@ import {
   formatToolsReport,
 } from "../context/analyzer.js";
 import type { ContextUsage } from "../context/analyzer.js";
+import {
+  buildSavingsLinesFromStore,
+  formatSavingsReportFromStore,
+  getFirstRunNotice,
+} from "../context/savings.js";
+import { getMetricsStore, getSessionId } from "../context-mode/hooks.js";
+import { getProjectStateDir, getProjectStatePath } from "../workspace/state-paths.js";
+import { openInEditor } from "../utils/editor.js";
 
 const REPORT_FILE = ".omp-context-breakdown.md";
 
@@ -33,13 +42,26 @@ export function handleContext(platform: Platform, ctx: PlatformContext): void {
 
     let systemPrompt = "";
     try {
-      systemPrompt = (ctx as any).getSystemPrompt?.() ?? "";
+      systemPrompt = systemPromptText((ctx as any).getSystemPrompt?.());
     } catch {
       // getSystemPrompt not available — continue without
     }
 
-    // If we have nothing to show, notify and bail
-    if (!usage && !systemPrompt) {
+    // L1 metrics surfaces
+    const store = getMetricsStore();
+    const sessionId = getSessionId();
+    const projectSlug = basename(getProjectStateDir(platform.paths, ctx.cwd));
+    const dbAbsPath = getProjectStatePath(platform.paths, ctx.cwd, "sessions", "metrics.db");
+    const sessionStartedAtMs = (() => {
+      try {
+        return store?.getSessionMeta(sessionId)?.started_at ?? null;
+      } catch {
+        return null;
+      }
+    })();
+
+    // Bail only when *nothing* is available: no usage, no system prompt, no metrics store.
+    if (!usage && !systemPrompt && !store) {
       ctx.ui.notify("Context data unavailable", "warning");
       return;
     }
@@ -47,7 +69,25 @@ export function handleContext(platform: Platform, ctx: PlatformContext): void {
     // Parse system prompt (may be empty)
     const sections = systemPrompt ? parseSystemPrompt(systemPrompt) : [];
     const activeTools = platform.getActiveTools();
-    const items = buildBreakdownItems(usage, sections, activeTools, !systemPrompt);
+    const baseItems = buildBreakdownItems(usage, sections, activeTools, !systemPrompt);
+
+    // Build the savings panel + first-run notice + footer
+    const noticeLine = getFirstRunNotice(store, projectSlug, dbAbsPath);
+    const savingsLines = buildSavingsLinesFromStore(
+      store,
+      sessionId,
+      sessionStartedAtMs,
+      dbAbsPath,
+    );
+    const footerLine = `Metrics DB: ${dbAbsPath}`;
+    const drillableSavings = new Set(savingsLines);
+
+    const items: typeof baseItems = [];
+    if (noticeLine) items.push({ line: noticeLine });
+    for (const line of savingsLines) items.push({ line });
+    items.push({ line: footerLine });
+    items.push(...baseItems);
+
     const lines = items.map(i => i.line);
 
     while (true) {
@@ -56,14 +96,17 @@ export function handleContext(platform: Platform, ctx: PlatformContext): void {
       });
       if (!choice || choice.trim() === "Close") break;
 
-      const item = items.find(i => i.line === choice);
-      if (!item || (!item.section && !item.toolNames)) continue;
-
       let report: string | null = null;
-      if (item.section) {
-        report = formatSectionReport(item.section);
-      } else if (item.toolNames) {
-        report = formatToolsReport(item.toolNames);
+      if (drillableSavings.has(choice)) {
+        report = formatSavingsReportFromStore(store, sessionId, sessionStartedAtMs);
+      } else {
+        const item = items.find(i => i.line === choice);
+        if (!item || (!item.section && !item.toolNames)) continue;
+        if (item.section) {
+          report = formatSectionReport(item.section);
+        } else if (item.toolNames) {
+          report = formatToolsReport(item.toolNames);
+        }
       }
 
       if (report) {
@@ -98,20 +141,4 @@ function writeReport(cwd: string, content: string): string {
     writeFileSync(fallback, content, "utf-8");
     return fallback;
   }
-}
-
-/** Open a file in the user's preferred editor */
-async function openInEditor(platform: Platform, filePath: string): Promise<void> {
-  const editor = process.env.VISUAL || process.env.EDITOR;
-  try {
-    if (editor) {
-      await platform.exec(editor, [filePath]);
-    } else {
-      const cmd = process.platform === "darwin" ? "open"
-        : process.platform === "win32" ? "start" : "xdg-open";
-      await platform.exec(cmd, [filePath]);
-    }
-  } catch {
-    // Editor open failed — non-fatal, file was still written
-  }
 }