@nklisch/pi-enhanced 0.1.0

package/node_modules/@nklisch/pi-clearance/src/runtime/config-commands/settings/panels.ts

@@ -0,0 +1,92 @@
+import { formatTuneCueStatus } from "../tune-cue.ts";
+import type { SettingsActionId } from "./actions.ts";
+import { BRIEFING_PANEL } from "./panels/briefing.ts";
+import { PACKS_PANEL } from "./panels/packs.ts";
+import { REVIEWER_PANEL } from "./panels/reviewer.ts";
+import { SCOPE_PANEL } from "./panels/scope.ts";
+import type {
+  SettingsPanelDescriptor,
+  SettingsReadModel,
+} from "./read-model.ts";
+
+export interface SettingsPanel {
+  readonly id: SettingsPanelDescriptor["id"];
+  readonly title: string;
+  readonly rows: (model: SettingsReadModel) => readonly SettingsRow[];
+  readonly actions: readonly SettingsActionId[];
+}
+
+export interface SettingsRow {
+  readonly label: string;
+  readonly value: string;
+  readonly meaning?: string;
+}
+
+export const SETTINGS_PANELS = [
+  REVIEWER_PANEL,
+  SCOPE_PANEL,
+  PACKS_PANEL,
+  BRIEFING_PANEL,
+] as const satisfies readonly SettingsPanel[];
+
+export function renderControlCenter(model: SettingsReadModel): string {
+  const rows: readonly SettingsRow[] = [
+    {
+      label: "Clearance mode",
+      value: model.currentMode.label,
+      meaning: model.currentMode.description,
+    },
+    {
+      label: "Tune mode",
+      value: formatTuneCueStatus(model.status.ratchet.active),
+      meaning: "Temporary Tune tools are inactive unless enabled.",
+    },
+    {
+      label: "Reviewer",
+      value: model.status.reviewer.path,
+      meaning: model.status.reviewer.consequence,
+    },
+    {
+      label: "Built-in writes",
+      value: "Project scope",
+      meaning:
+        "Typed edit/write can clear inside proven Safe Zones; No-Go Zones still block.",
+    },
+    ...BRIEFING_PANEL.rows(model),
+  ];
+  return [
+    "# Clearance Desk settings",
+    "",
+    "## Current mode",
+    markdownTable(rows),
+    "",
+    "## Mode choices",
+    markdownTable(
+      model.modes.map((mode) => ({
+        label: mode.label,
+        value: mode.mode,
+        meaning: mode.description,
+      })),
+    ),
+    "",
+    "## Details",
+    ...model.panels.map(
+      (panel) =>
+        `- ${panel.title}: ${panel.summary} (drill: \`${panel.drillActionId}\`)`,
+    ),
+  ].join("\n");
+}
+
+function markdownTable(rows: readonly SettingsRow[]): string {
+  return [
+    "| Setting | Value | Meaning |",
+    "|---|---|---|",
+    ...rows.map(
+      (row) =>
+        `| ${escapeCell(row.label)} | ${escapeCell(row.value)} | ${escapeCell(row.meaning ?? "")} |`,
+    ),
+  ].join("\n");
+}
+function escapeCell(value: string): string {
+  return value.replaceAll("|", "\\|").replaceAll("\n", " ");
+}

package/node_modules/@nklisch/pi-clearance/src/runtime/config-commands/settings/read-model.ts

@@ -0,0 +1,167 @@
+import type {
+  ResolvedProjectScope,
+  ResolvedReviewNotePreference,
+} from "../../../config/loader.ts";
+import type { ClearanceMode } from "../../../config/schema.ts";
+import type { AutoReviewerStatusView } from "../../auto-reviewer-read-models.ts";
+import type { ReviewDecisionDisplayCapability } from "../../review-decision-display.ts";
+import type { SettingsActionId } from "./actions.ts";
+
+export interface SettingsModeCopy {
+  readonly mode: ClearanceMode;
+  readonly label: string;
+  readonly description: string;
+}
+
+export type SettingsBriefingFallbackSurface =
+  | ReviewDecisionDisplayCapability
+  | "unknown";
+
+export interface SettingsBriefingRow {
+  readonly mode: ResolvedReviewNotePreference["mode"];
+  readonly showModelLabel: boolean;
+  readonly accent: boolean;
+  readonly configurable: true;
+  readonly fallbackSurface: SettingsBriefingFallbackSurface;
+  readonly note: string;
+}
+
+export interface SettingsProjectScope extends ResolvedProjectScope {
+  readonly safeHomeUseDefaults?: boolean;
+  readonly agentSupportUseDefaults?: boolean;
+}
+
+/** A pack row for the settings pack explorer. */
+export interface SettingsPackRow {
+  readonly id: string;
+  readonly title: string;
+  readonly enabled: boolean;
+  /** Only package packs can be toggled; baseline, floor, and config packs are fixed here. */
+  readonly toggleable: boolean;
+  readonly source: string;
+  /** Enablement scopes from user-owned config; drives the toggle's target scope. */
+  readonly enabledInGlobal: boolean;
+  readonly enabledInProject: boolean;
+}
+
+/** A reviewer model option for the settings reviewer panel. */
+export interface SettingsReviewerModelOption {
+  /** Canonical provider/modelId spec written to config. */
+  readonly spec: string;
+  readonly label: string;
+}
+
+export interface SettingsPanelDescriptor {
+  readonly id: "reviewer" | "scope" | "packs" | "briefing";
+  readonly title: string;
+  readonly summary: string;
+  readonly drillActionId: SettingsActionId;
+}
+
+export interface SettingsReadModel {
+  readonly modes: readonly SettingsModeCopy[];
+  readonly currentMode: SettingsModeCopy;
+  readonly status: AutoReviewerStatusView;
+  readonly projectScope: SettingsProjectScope;
+  readonly briefing: SettingsBriefingRow;
+  readonly packs: readonly SettingsPackRow[];
+  readonly reviewerModels: readonly SettingsReviewerModelOption[];
+  readonly panels: readonly SettingsPanelDescriptor[];
+}
+
+export const SETTINGS_MODE_COPIES = [
+  {
+    mode: "off",
+    label: "Off",
+    description:
+      "Nothing is asked or reviewed; catastrophic commands and your deny rules still block.",
+  },
+  {
+    mode: "ask",
+    label: "Ask",
+    description:
+      "Known-safe commands run automatically; anything else asks you. No model is called.",
+  },
+  {
+    mode: "auto",
+    label: "Auto",
+    description:
+      "Known-safe commands run automatically; a model reviews the rest before asking you.",
+  },
+] as const satisfies readonly SettingsModeCopy[];
+
+export const DEFAULT_REVIEW_NOTE_PREFERENCE = {
+  mode: "reason+accent",
+  showModelLabel: false,
+  accent: true,
+} as const satisfies ResolvedReviewNotePreference;
+
+export const DEFAULT_SETTINGS_BRIEFING_ROW = buildSettingsBriefingRow(
+  DEFAULT_REVIEW_NOTE_PREFERENCE,
+);
+
+const SETTINGS_PANEL_DESCRIPTORS = [
+  {
+    id: "reviewer",
+    title: "Reviewer",
+    summary:
+      "Configured model and prompt details (read-only except model selection).",
+    drillActionId: "reviewer.open" as const,
+  },
+  {
+    id: "scope",
+    title: "Project scope",
+    summary: "Safe Zones, writable project paths, temp paths, and No-Go Zones.",
+    drillActionId: "scope.open" as const,
+  },
+  {
+    id: "packs",
+    title: "Pack explorer",
+    summary: "Baseline and configured policy packs.",
+    drillActionId: "packs.open" as const,
+  },
+  {
+    id: "briefing",
+    title: "Stream briefing",
+    summary:
+      "Inline review-note display preferences: reason text, model label, accent, or off.",
+    drillActionId: "briefing.open" as const,
+  },
+] as const satisfies readonly SettingsPanelDescriptor[];
+
+export function buildSettingsReadModel(input: {
+  readonly status: AutoReviewerStatusView;
+  readonly projectScope: SettingsProjectScope;
+  readonly reviewNoteDisplay?: ResolvedReviewNotePreference;
+  readonly packs?: readonly SettingsPackRow[];
+  readonly reviewerModels?: readonly SettingsReviewerModelOption[];
+}): SettingsReadModel {
+  const currentMode = SETTINGS_MODE_COPIES.find(
+    (mode) => mode.mode === input.status.mode,
+  );
+  if (currentMode === undefined)
+    throw new Error(`unknown clearance mode: ${input.status.mode}`);
+  return {
+    modes: SETTINGS_MODE_COPIES.map((mode) => ({ ...mode })),
+    currentMode: { ...currentMode },
+    status: input.status,
+    projectScope: input.projectScope,
+    briefing: buildSettingsBriefingRow(
+      input.reviewNoteDisplay ?? DEFAULT_REVIEW_NOTE_PREFERENCE,
+    ),
+    packs: input.packs ?? [],
+    reviewerModels: input.reviewerModels ?? [],
+    panels: SETTINGS_PANEL_DESCRIPTORS.map((panel) => ({ ...panel })),
+  };
+}
+
+function buildSettingsBriefingRow(
+  preference: ResolvedReviewNotePreference,
+): SettingsBriefingRow {
+  return {
+    ...preference,
+    configurable: true,
+    fallbackSurface: "unknown",
+    note: "Inline review-note display; changes write global.json after confirmation.",
+  };
+}

package/node_modules/@nklisch/pi-clearance/src/runtime/config-commands/settings.ts

@@ -0,0 +1,225 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+import { buildAutoReviewerStatusView } from "../auto-reviewer-read-models.ts";
+import type { ReviewerModelRegistry } from "../reviewer-model.ts";
+import {
+  canOpenSettingsNativeUi,
+  openSettingsNativeUi,
+} from "./settings/native-ui.ts";
+import {
+  buildSettingsReadModel,
+  type SettingsReadModel,
+} from "./settings/read-model.ts";
+import {
+  type AutoReviewerCommandDependencies,
+  type CommandReport,
+  resolvePolicyReport,
+  usageReport,
+} from "./types.ts";
+
+type SettingsNativePanel = SettingsReadModel["panels"][number]["id"];
+
+interface SettingsCommandDetails {
+  readonly controlCenter?: SettingsReadModel;
+  readonly nativeUi?: unknown;
+  readonly reason?: "native-ui-unavailable";
+}
+
+export async function handleSettingsCommand(
+  tokens: readonly string[],
+  ctx: ExtensionCommandContext,
+  deps: AutoReviewerCommandDependencies,
+): Promise<CommandReport<SettingsCommandDetails | unknown>> {
+  if (tokens.length !== 0) {
+    return usageReport("Expected `settings` with no additional arguments.");
+  }
+
+  const built = await buildSettingsCommandView(ctx, deps);
+  if (!built.ok) {
+    return built.report;
+  }
+
+  return await openSettingsUiCommand({
+    ctx,
+    deps,
+    model: built.model,
+    title: "Pi Clearance settings",
+  });
+}
+
+export async function handleScopeSettingsPanelCommand(
+  ctx: ExtensionCommandContext,
+  deps: AutoReviewerCommandDependencies,
+): Promise<CommandReport> {
+  const built = await buildSettingsCommandView(ctx, deps);
+  if (!built.ok) {
+    return built.report;
+  }
+
+  return await openSettingsUiCommand({
+    ctx,
+    deps,
+    model: built.model,
+    title: "Project scope settings",
+    initialPanel: "scope",
+  });
+}
+
+async function openSettingsUiCommand(input: {
+  readonly ctx: ExtensionCommandContext;
+  readonly deps: AutoReviewerCommandDependencies;
+  readonly model: SettingsReadModel;
+  readonly title: string;
+  readonly initialPanel?: SettingsNativePanel;
+}): Promise<CommandReport<SettingsCommandDetails | unknown>> {
+  if (!canOpenSettingsNativeUi(input.ctx)) {
+    return nativeUiUnavailableReport(input.model);
+  }
+
+  const native = await openSettingsNativeUi({
+    ctx: input.ctx,
+    deps: input.deps,
+    initialModel: input.model,
+    ...(input.initialPanel === undefined
+      ? {}
+      : { initialPanel: input.initialPanel }),
+    reload: async () => {
+      const refreshed = await buildSettingsCommandView(input.ctx, input.deps);
+      return refreshed.ok
+        ? { ok: true, model: refreshed.model }
+        : { ok: false, report: refreshed.report };
+    },
+  });
+
+  if (!native.ok) {
+    return native.report;
+  }
+
+  return {
+    title: input.title,
+    summary: native.summary,
+    markdown: "",
+    details: {
+      controlCenter: input.model,
+      nativeUi: native.details,
+    },
+    level: native.level,
+  };
+}
+
+function nativeUiUnavailableReport(
+  model: SettingsReadModel,
+): CommandReport<SettingsCommandDetails> {
+  const summary =
+    "Pi Clearance settings require Pi's native custom UI; no markdown fallback was rendered and no config changes were written.";
+  return {
+    title: "Pi Clearance settings unavailable",
+    summary,
+    // Keep this to one notice line: hosts without custom UI need visible
+    // feedback, but settings must not degrade into a transcript report.
+    markdown: summary,
+    details: {
+      reason: "native-ui-unavailable",
+      controlCenter: model,
+    },
+    level: "error",
+  };
+}
+
+async function buildSettingsCommandView(
+  ctx: ExtensionCommandContext,
+  deps: AutoReviewerCommandDependencies,
+): Promise<
+  | {
+      readonly ok: true;
+      readonly model: SettingsReadModel;
+    }
+  | { readonly ok: false; readonly report: CommandReport }
+> {
+  const policy = await resolvePolicyReport(ctx, deps);
+  if (!policy.ok) {
+    return { ok: false, report: policy.report };
+  }
+
+  const status = buildAutoReviewerStatusView({
+    ctx,
+    policy: policy.policy,
+    ratchet: deps.manager.getStatus(),
+  });
+  // Thread the raw configured behavior toggles through: the resolved scope
+  // loses them, and preset inference compares configured (not derived)
+  // values.
+  const rawScope = policy.policy.config.sourceSnapshots?.project.projectScope;
+  const projectScope =
+    rawScope === undefined
+      ? policy.policy.config.projectScope
+      : {
+          ...policy.policy.config.projectScope,
+          safeHomeUseDefaults: rawScope.safeHomeUseDefaults,
+          ...(rawScope.agentSupportUseDefaults === undefined
+            ? {}
+            : { agentSupportUseDefaults: rawScope.agentSupportUseDefaults }),
+          homePathBehavior: rawScope.homePathBehavior,
+          sensitivePathBehavior: rawScope.sensitivePathBehavior,
+        };
+  const model = buildSettingsReadModel({
+    status,
+    projectScope,
+    reviewNoteDisplay: policy.policy.config.display.reviewNote,
+    packs: policy.policy.registry.entries.map((entry) => {
+      const enablement = policy.policy.config.packEnablement;
+      return {
+        id: entry.id,
+        title: entry.metadata.title,
+        enabled: entry.availability.enabled,
+        toggleable: entry.source.kind === "package",
+        source: entry.source.kind,
+        enabledInGlobal:
+          enablement.global.enabledPackagePacks.includes(entry.id) &&
+          !enablement.global.disabledPackagePacks.includes(entry.id),
+        enabledInProject:
+          enablement.project.enabledPackagePacks.includes(entry.id) &&
+          !enablement.project.disabledPackagePacks.includes(entry.id),
+      };
+    }),
+    reviewerModels: availableReviewerModels(ctx),
+  });
+
+  return { ok: true, model };
+}
+
+const REVIEWER_MODEL_OPTION_LIMIT = 12;
+
+/** Available reviewer model specs (provider/modelId) with configured auth. */
+export function availableReviewerModels(
+  ctx: ExtensionCommandContext,
+): readonly { readonly spec: string; readonly label: string }[] {
+  // Pi's ModelRegistry.hasConfiguredAuth takes the MODEL, not a provider
+  // string — passing a string silently filters out every model.
+  const registry = (ctx as { readonly modelRegistry?: unknown })
+    .modelRegistry as ReviewerModelRegistry | undefined;
+  if (
+    registry === undefined ||
+    typeof registry.getAll !== "function" ||
+    typeof registry.hasConfiguredAuth !== "function"
+  ) {
+    return [];
+  }
+
+  try {
+    return registry
+      .getAll()
+      .filter((model) => registry.hasConfiguredAuth(model))
+      .map((model) => ({
+        spec: `${model.provider}/${model.id}`,
+        label:
+          typeof model.name === "string" && model.name.length > 0
+            ? `${model.name} (${model.provider}/${model.id})`
+            : `${model.provider}/${model.id}`,
+      }))
+      .sort((a, b) => a.spec.localeCompare(b.spec))
+      .slice(0, REVIEWER_MODEL_OPTION_LIMIT);
+  } catch {
+    return [];
+  }
+}

package/node_modules/@nklisch/pi-clearance/src/runtime/config-commands/setup.ts

@@ -0,0 +1,135 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+import type { ClearanceMode } from "../../config/schema.ts";
+import { buildAutoReviewerStatusView } from "../auto-reviewer-read-models.ts";
+import { dispatchSettingsAction } from "./settings/dispatcher.ts";
+import { buildSettingsReadModel } from "./settings/read-model.ts";
+import {
+  type AutoReviewerCommandDependencies,
+  type CommandPi,
+  type CommandReport,
+  resolvePolicyReport,
+  usageReport,
+} from "./types.ts";
+
+const MODE_OPTIONS: readonly {
+  readonly mode: ClearanceMode;
+  readonly label: string;
+  readonly description: string;
+}[] = [
+  {
+    mode: "off",
+    label: "Off",
+    description:
+      "Nothing is asked or reviewed; catastrophic commands and your deny rules still block.",
+  },
+  {
+    mode: "ask",
+    label: "Ask",
+    description:
+      "Known-safe commands run automatically; anything else asks you. No model is called.",
+  },
+  {
+    mode: "auto",
+    label: "Auto",
+    description:
+      "Known-safe commands run automatically; a model reviews the rest before asking you.",
+  },
+];
+
+export async function handleSetupCommand(
+  tokens: readonly string[],
+  ctx: ExtensionCommandContext,
+  _pi: CommandPi,
+  deps: AutoReviewerCommandDependencies,
+): Promise<CommandReport> {
+  if (tokens.length !== 0)
+    return usageReport("Expected `setup` with no additional arguments.");
+  if (ctx.hasUI !== true) {
+    return {
+      title: "Setup requires UI",
+      summary:
+        "The setup wizard requires interactive Pi UI; no config changes were written.",
+      markdown: "# Setup requires UI\n\nNo config changes were written.",
+      details: { reason: "ui-required", applied: [] },
+      level: "error",
+    };
+  }
+
+  const policy = await resolvePolicyReport(ctx, deps);
+  if (!policy.ok) return policy.report;
+  const status = buildAutoReviewerStatusView({
+    ctx,
+    policy: policy.policy,
+    ratchet: deps.manager.getStatus(),
+  });
+  const model = buildSettingsReadModel({
+    status,
+    projectScope: policy.policy.config.projectScope,
+    reviewNoteDisplay: policy.policy.config.display.reviewNote,
+  });
+  const selection = await safeSelect(
+    ctx,
+    "Setup: choose Clearance mode",
+    MODE_OPTIONS.map(
+      (option) =>
+        `${option.label} — ${option.description}${option.mode === model.currentMode.mode ? " (current)" : ""}`,
+    ),
+  );
+  if (selection === undefined) {
+    return {
+      title: "Setup cancelled",
+      summary: "No mode was selected; no config changes were written.",
+      markdown: "# Setup cancelled\n\nNo config changes were written.",
+      details: { reason: "cancelled" },
+      level: "warning",
+    };
+  }
+  const option = MODE_OPTIONS.find((candidate) =>
+    selection.startsWith(`${candidate.label} —`),
+  );
+  if (option === undefined)
+    return {
+      title: "Setup failed",
+      summary: "Unknown mode selection; no config changes were written.",
+      markdown: "# Setup failed\n\nNo config changes were written.",
+      details: { reason: "failed" },
+      level: "error",
+    };
+
+  const report = await dispatchSettingsAction(
+    { id: "mode.set", args: { mode: option.mode } },
+    ctx,
+    deps,
+  );
+  return {
+    ...report,
+    title:
+      report.title === "Settings updated"
+        ? "Pi Clearance setup complete"
+        : report.title,
+    summary:
+      report.title === "Settings updated"
+        ? `Clearance mode set to ${option.label}.`
+        : report.summary,
+    markdown: [
+      "# Pi Clearance setup",
+      "",
+      `- Mode: ${option.label} — ${option.description}`,
+      "",
+      report.markdown,
+    ].join("\n"),
+  };
+}
+
+async function safeSelect(
+  ctx: ExtensionCommandContext,
+  title: string,
+  options: readonly string[],
+): Promise<string | undefined> {
+  try {
+    return await ctx.ui.select(title, [...options]);
+  } catch {
+    return undefined;
+  }
+}

package/node_modules/@nklisch/pi-clearance/src/runtime/config-commands/status.ts

@@ -0,0 +1,64 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+import {
+  buildAutoReviewerStatusView,
+  formatReviewerContextModeLabel,
+} from "../auto-reviewer-read-models.ts";
+import { formatTuneCueStatus } from "./tune-cue.ts";
+import {
+  type AutoReviewerCommandDependencies,
+  type CommandReport,
+  resolvePolicyReport,
+  usageReport,
+} from "./types.ts";
+
+export async function handleStatusCommand(
+  tokens: readonly string[],
+  ctx: ExtensionCommandContext,
+  deps: AutoReviewerCommandDependencies,
+): Promise<CommandReport> {
+  const includeWarnings = tokens.length === 1 && tokens[0] === "--warnings";
+  if (tokens.length > 1 || (tokens.length === 1 && !includeWarnings))
+    return usageReport("Expected `status` or `status --warnings`.");
+  const policy = await resolvePolicyReport(ctx, deps);
+  if (!policy.ok) return policy.report;
+  const details = buildAutoReviewerStatusView({
+    ctx,
+    policy: policy.policy,
+    ratchet: deps.manager.getStatus(),
+    includeRegistryWarnings: includeWarnings,
+  });
+  return {
+    title: "Pi Clearance status",
+    summary: `Mode ${details.mode}; Tune ${details.ratchet.active ? "on" : "off"}; ${details.packs.enabled}/${details.packs.total} packs enabled; ${details.warnings.length} warning(s).`,
+    markdown: formatStatusMarkdown(details, includeWarnings),
+    details,
+    level: details.warnings.length === 0 ? "info" : "warning",
+  };
+}
+
+function formatStatusMarkdown(
+  details: ReturnType<typeof buildAutoReviewerStatusView>,
+  includeWarnings: boolean,
+): string {
+  const lines = [
+    "# Pi Clearance status",
+    "",
+    `- Mode: ${details.mode}`,
+    `- Tune mode: ${formatTuneCueStatus(details.ratchet.active)}`,
+    `- Project: ${details.project.trusted ? "trusted" : "untrusted"} at \`${details.project.cwd}\``,
+    `- Review path: ${details.reviewer.path}; ${details.reviewer.consequence}`,
+    `- Reviewer prompt: ${details.reviewer.promptPosture}; context ${formatReviewerContextModeLabel(details.reviewer.contextMode)}`,
+    `- Reviewer model configured: ${details.reviewer.configuredModel === null ? "none" : `\`${details.reviewer.configuredModel}\``}`,
+    `- Reviewer model resolved: ${details.reviewer.resolvedModel === null ? "none" : `\`${details.reviewer.resolvedModel}\``} (${details.reviewer.resolvedModelSource})`,
+    `- Packs: ${details.packs.enabled} enabled / ${details.packs.total} total`,
+    `- Warnings: ${details.warnings.length}`,
+  ];
+  if (includeWarnings && details.warnings.length > 0)
+    lines.push(
+      "",
+      "## Warnings",
+      ...details.warnings.map((warning) => `- ${warning}`),
+    );
+  return lines.join("\n");
+}