@klhapp/skillmux 1.9.3 → 1.11.0

package/src/commands/audit.ts

@@ -1,13 +1,13 @@
-import { expandHome, loadConfig } from "../config";
-import { countPrunable, openAudit, pruneAuditBefore } from "../db";
-import { parseSince } from "../stats";
 import { emitSuccess } from "../output";
 import { confirmIfNeeded } from "./shared";
+import type { ContextAdapter } from "../adapters";
+import type { ResolvedContext } from "../context";
+import { isGlobalFlag, isGlobalFlagWithValue } from "../global-flags";
 
 export async function runAudit(
   subCommand: string,
   args: string[],
-  options: { isJson: boolean; dryRun: boolean },
+  options: { isJson: boolean; dryRun: boolean; context: ResolvedContext; adapter: ContextAdapter },
 ): Promise<void> {
   if (subCommand !== "prune") {
     throw new Error("usage: skillmux audit prune [--older-than <window>] [--dry-run] [--yes] [--json]");
@@ -21,68 +21,65 @@ export async function runAudit(
     if (arg === "--older-than") olderThan = args[++i];
     else if (arg === "--dry-run") dryRun = true;
     else if (arg === "--yes") yes = true;
-    else if (arg === "--json") {
-      // handled globally by main()'s isJson flag; recognized here so it isn't rejected
+    else if (isGlobalFlag(arg, "--json", "--allow-insecure", "--verbose")) {
+      // handled globally by main()'s flags; recognized here so it isn't rejected
+    } else if (isGlobalFlagWithValue(arg)) {
+      i++; // skip flag value
     } else if (arg?.startsWith("--")) {
       throw new Error(`unknown audit prune option: ${arg}`);
     }
   }
 
-  const config = await loadConfig();
-  const stateDir = expandHome(config.state_dir);
-
-  let cutoff: Date;
-  if (olderThan) {
-    cutoff = parseSince(olderThan);
-  } else {
-    const retentionDays = config.audit?.retention_days ?? 90;
-    if (retentionDays <= 0) {
-      emitSuccess(
-        { isJson: options.isJson },
-        { audit_deleted: 0, fetch_deleted: 0, admin_audit_deleted: 0, dry_run: dryRun, cutoff: null },
-        () => console.log("prune: audit.retention_days is 0 (pruning disabled); nothing to do"),
-      );
-      return;
-    }
-    cutoff = new Date(Date.now() - retentionDays * 86_400_000);
-  }
-  const cutoffIso = cutoff.toISOString();
-
-  const db = openAudit(stateDir);
-  try {
-    if (dryRun) {
-      const counts = countPrunable(db, cutoffIso);
-      emitSuccess(
-        { isJson: options.isJson },
-        { ...counts, dry_run: true, cutoff: cutoffIso },
-        () =>
-          console.log(
-            `prune: audit=${counts.audit_deleted} fetch=${counts.fetch_deleted} admin_audit=${counts.admin_audit_deleted} (dry-run)`,
-          ),
-      );
-      return;
-    }
-
-    if (
-      !(await confirmIfNeeded({
-        confirmed: yes,
-        isJson: options.isJson,
-        prompt: `prune audit rows older than ${cutoffIso}?`,
-        nonInteractiveError: "skillmux audit prune requires --yes when run non-interactively",
-      }))
-    )
-      return;
-
-    const counts = pruneAuditBefore(db, cutoffIso);
+  if (dryRun) {
+    const counts = await options.adapter.auditCount(olderThan);
     emitSuccess(
       { isJson: options.isJson },
-      { ...counts, dry_run: false, cutoff: cutoffIso },
+      counts,
       () =>
         console.log(
-          `prune: audit=${counts.audit_deleted} fetch=${counts.fetch_deleted} admin_audit=${counts.admin_audit_deleted}`,
+          counts.cutoff === null
+            ? "prune: audit.retention_days is 0 (pruning disabled); nothing to do"
+            : `prune: audit=${counts.audit_deleted} fetch=${counts.fetch_deleted} admin_audit=${counts.admin_audit_deleted} (dry-run)`,
         ),
     );
-  } finally {
-    db.close();
+    return;
   }
+
+  // Pre-fetch count / cutoff info for confirmation prompt if local or remote
+  const countResult = await options.adapter.auditCount(olderThan);
+  if (countResult.cutoff === null) {
+    emitSuccess(
+      { isJson: options.isJson },
+      { audit_deleted: 0, fetch_deleted: 0, admin_audit_deleted: 0, dry_run: false, cutoff: null },
+      () => console.log("prune: audit.retention_days is 0 (pruning disabled); nothing to do"),
+    );
+    return;
+  }
+
+  if (
+    !(await confirmIfNeeded({
+      confirmed: yes,
+      isJson: options.isJson,
+      prompt: `prune audit rows older than ${countResult.cutoff}?`,
+      nonInteractiveError: "skillmux audit prune requires --yes when run non-interactively",
+    }))
+  )
+    return;
+
+  // Reuse the exact cutoff already shown in the confirmation prompt — recomputing
+  // it here (if olderThan was left unset) could drift from what was confirmed,
+  // e.g. if audit.retention_days changed between the two calls on a remote target.
+  const counts = await options.adapter.auditPrune({
+    older_than: countResult.cutoff,
+    dry_run: false,
+    confirm: true,
+  });
+  emitSuccess(
+    { isJson: options.isJson },
+    counts,
+    () =>
+      console.log(
+        `prune: audit=${counts.audit_deleted} fetch=${counts.fetch_deleted} admin_audit=${counts.admin_audit_deleted}`,
+      ),
+  );
 }

package/src/commands/config.ts

@@ -1,9 +1,10 @@
 import { expandHome, migrateLegacyPaths, resolveConfigPath } from "../config";
-import { type TargetAdapter } from "../adapters";
-import { type ResolvedTarget } from "../context";
+import { type ContextAdapter } from "../adapters";
+import { type ResolvedContext } from "../context";
 import { applyConfigInit, planConfigInit, type ConfigInitPlan } from "../setup";
-import { emitSuccess, isInteractive, renderTargetBanner } from "../output";
+import { emitSuccess, isInteractive, renderContextBanner, unknownSubcommandError } from "../output";
 import { confirmAction } from "./shared";
+import { isGlobalFlag } from "../global-flags";
 function emitConfigInitOutcome(
   ctx: { isJson: boolean },
   opts: {
@@ -37,10 +38,10 @@ function emitConfigInitOutcome(
 }
 
 export async function handleConfigCommand(
-  adapter: TargetAdapter,
+  adapter: ContextAdapter,
   sub: string,
   args: string[],
-  ctx: { target: ResolvedTarget; isJson: boolean; dryRun: boolean },
+  ctx: { context: ResolvedContext; isJson: boolean; dryRun: boolean },
 ) {
   if (sub === "init") {
     let vaultPath: string | undefined;
@@ -53,7 +54,7 @@ export async function handleConfigCommand(
           throw new Error("usage: skillmux config init --vault <path> --yes");
       } else if (option === "--yes") {
         yes = true;
-      } else if (option === "--dry-run" || option === "--json") {
+      } else if (isGlobalFlag(option, "--dry-run", "--json")) {
         continue;
       } else {
         throw new Error(`unknown config init option: ${option}`);
@@ -95,7 +96,7 @@ export async function handleConfigCommand(
       if (!ctx.isJson && isInteractive()) {
         if (
           !(await confirmAction(
-            `Create ${plan.configPath} with vault_path ${plan.vaultPath}?`,
+            `create ${plan.configPath} with vault_path ${plan.vaultPath}?`,
           ))
         ) {
           console.log("config init cancelled; nothing written");
@@ -126,8 +127,8 @@ export async function handleConfigCommand(
   if (sub === "show") {
     const withSources = args.includes("--sources");
     const data = await adapter.getConfigShow();
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, data, () => {
-      renderTargetBanner(ctx.target);
+    emitSuccess({ isJson: ctx.isJson, context: ctx.context }, data, () => {
+      renderContextBanner(ctx.context);
       if (withSources) {
         const policy =
           data.effective.config?.environment_overrides === false
@@ -150,7 +151,7 @@ export async function handleConfigCommand(
     if (!key) throw new Error("usage: skillmux config get <key>");
     const val = await adapter.getConfigGet(key);
     emitSuccess(
-      { isJson: ctx.isJson, target: ctx.target },
+      { isJson: ctx.isJson, context: ctx.context },
       { key, value: val },
       () => {
         console.log(
@@ -163,18 +164,16 @@ export async function handleConfigCommand(
 
   if (sub === "validate") {
     const res = await adapter.configValidate();
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      console.log(
-        res.valid ? "Configuration is valid." : "Configuration is invalid.",
-      );
+    emitSuccess({ isJson: ctx.isJson, context: ctx.context }, res, () => {
+      console.log(res.valid ? "configuration is valid" : "configuration is invalid");
     });
     return;
   }
 
   if (sub === "diff") {
     const res = await adapter.configDiff();
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      renderTargetBanner(ctx.target);
+    emitSuccess({ isJson: ctx.isJson, context: ctx.context }, res, () => {
+      renderContextBanner(ctx.context);
       console.log(JSON.stringify(res.diff, null, 2));
     });
     return;
@@ -187,8 +186,8 @@ export async function handleConfigCommand(
       throw new Error("usage: skillmux config set <key> <value> [--dry-run]");
     }
     const res = await adapter.configSet(key, value, { dryRun: ctx.dryRun });
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      renderTargetBanner(ctx.target);
+    emitSuccess({ isJson: ctx.isJson, context: ctx.context }, res, () => {
+      renderContextBanner(ctx.context);
       const prefix = ctx.dryRun ? "[dry-run] " : "";
       console.log(
         `${prefix}${key}: ${JSON.stringify(res.prior_val)} -> ${JSON.stringify(res.resulting_val)}`,
@@ -202,16 +201,24 @@ export async function handleConfigCommand(
 
   if (sub === "status") {
     const res = await adapter.configStatus();
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      renderTargetBanner(ctx.target);
-      console.log(`Runtime: ${res.runtime}`);
-      console.log(`Deployment runtime: ${res.deployment_runtime}`);
-      console.log(`Image variant: ${res.image_variant ?? "none"}`);
-      console.log(`Active revision: ${res.active_revision}`);
-      console.log(`Readiness: ${res.readiness.status}`);
+    emitSuccess({ isJson: ctx.isJson, context: ctx.context }, res, () => {
+      renderContextBanner(ctx.context);
+      console.log(`runtime: ${res.runtime}`);
+      console.log(`deployment runtime: ${res.deployment_runtime}`);
+      console.log(`image variant: ${res.image_variant ?? "none"}`);
+      console.log(`active revision: ${res.active_revision}`);
+      console.log(`readiness: ${res.readiness.status}`);
     });
     return;
   }
 
-  throw new Error("usage: skillmux config show");
+  throw unknownSubcommandError("config", sub, [
+    "init",
+    "show",
+    "get",
+    "set",
+    "validate",
+    "diff",
+    "status",
+  ]);
 }

package/src/commands/context.ts

@@ -0,0 +1,104 @@
+import {
+  addContext,
+  getCurrentContext,
+  listContexts,
+  removeContext,
+  useContext,
+  type ResolvedContext,
+} from "../context";
+import {
+  emitSuccess,
+  renderTable,
+  renderContextBanner,
+  unknownSubcommandError,
+} from "../output";
+
+export async function handleContextCommand(
+  sub: string,
+  args: string[],
+  ctx: { context: ResolvedContext; isJson: boolean },
+) {
+  if (sub === "list") {
+    const contexts = await listContexts();
+    emitSuccess({ isJson: ctx.isJson, context: ctx.context }, contexts, () => {
+      renderContextBanner(ctx.context);
+      renderTable(
+        [
+          { key: "name", header: "NAME" },
+          { key: "server", header: "SERVER" },
+          { key: "token_env", header: "TOKEN_ENV" },
+          { key: "isDefault", header: "DEFAULT" },
+        ],
+        contexts.map((c) => ({
+          ...c,
+          token_env: c.token_env ?? "-",
+          isDefault: c.isDefault ? "*" : "",
+        })),
+      );
+    });
+    return;
+  }
+
+  if (sub === "current") {
+    const current = await getCurrentContext();
+    emitSuccess({ isJson: ctx.isJson, context: ctx.context }, current, () => {
+      renderContextBanner(ctx.context);
+      console.log(`Current context: ${current.name} (${current.server})`);
+    });
+    return;
+  }
+
+  if (sub === "add") {
+    const name = args[0];
+    let server: string | undefined;
+    let tokenEnv: string | undefined;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--server") server = args[++i];
+      else if (args[i] === "--token-env") tokenEnv = args[++i];
+    }
+    if (!name || !server) {
+      throw new Error(
+        "usage: skillmux context add <name> --server <url> [--token-env <env_name>]",
+      );
+    }
+    await addContext(name, { server, token_env: tokenEnv });
+    emitSuccess(
+      { isJson: ctx.isJson, context: ctx.context },
+      { name, server, token_env: tokenEnv },
+      () => {
+        console.log(`Added context "${name}" -> ${server}`);
+      },
+    );
+    return;
+  }
+
+  if (sub === "use") {
+    const name = args[0];
+    if (!name) throw new Error("usage: skillmux context use <name>");
+    await useContext(name);
+    emitSuccess(
+      { isJson: ctx.isJson, context: ctx.context },
+      { default_context: name },
+      () => {
+        console.log(`Switched default context to "${name}"`);
+      },
+    );
+    return;
+  }
+
+  if (sub === "remove") {
+    const name = args[0];
+    if (!name) throw new Error("usage: skillmux context remove <name>");
+    await removeContext(name);
+    emitSuccess(
+      { isJson: ctx.isJson, context: ctx.context },
+      { removed: name },
+      () => {
+        console.log(`Removed context "${name}"`);
+      },
+    );
+    return;
+  }
+
+  throw unknownSubcommandError("context", sub, ["add", "list", "current", "use", "remove"]);
+}

package/src/commands/core.ts

@@ -1,6 +1,6 @@
 import { expandHome } from "../config";
 import { pinCore, unpinCore, validateManifest, writeManifestAtomic } from "../manifest";
-import { emitSuccess } from "../output";
+import { emitSuccess, unknownSubcommandError } from "../output";
 import { confirmIfNeeded, loadManifestContext } from "./shared";
 export async function runCore(
   subCommand: string,
@@ -8,7 +8,7 @@ export async function runCore(
   options: { isJson: boolean; dryRun: boolean },
 ): Promise<void> {
   if (subCommand !== "pin" && subCommand !== "unpin") {
-    throw new Error("usage: skillmux core <pin|unpin>");
+    throw unknownSubcommandError("core", subCommand, ["pin", "unpin"]);
   }
   const skillIds = args.filter((arg) => !arg.startsWith("-"));
   if (skillIds.length === 0) {
@@ -48,5 +48,9 @@ export async function runCore(
   )
     return;
   writeManifestAtomic(manifestPath, updated);
-  console.log(`${subCommand}: [core] ${skillIds.join(", ")}`);
+  emitSuccess(
+    { isJson: options.isJson },
+    { subcommand: subCommand, skill_ids: skillIds },
+    () => console.log(`${subCommand}: [core] ${skillIds.join(", ")}`),
+  );
 }

package/src/commands/doctor.ts

@@ -0,0 +1,97 @@
+import { resolveConfigPath } from "../config";
+import { diagnose } from "../doctor";
+import { getEffectiveConfig } from "../config-service";
+import type { ContextAdapter } from "../adapters";
+import type { ResolvedContext } from "../context";
+import { isGlobalFlag, isGlobalFlagWithValue } from "../global-flags";
+import {
+  emitSuccess,
+  green,
+  red,
+  renderContextBanner,
+} from "../output";
+
+/**
+ * doctor takes no options of its own, but it still has to reject unknown ones
+ * rather than silently ignoring them the way every other command does.
+ */
+export function parseDoctorArgs(args: readonly string[]): void {
+  for (let i = 0; i < args.length; i++) {
+    const option = args[i];
+    if (isGlobalFlag(option, "--json", "--allow-insecure", "--verbose")) {
+      // handled globally by main(); recognized here so it isn't rejected
+    } else if (isGlobalFlagWithValue(option)) {
+      // handled globally by main()'s resolveContext(); skip its value too
+      i++;
+    } else {
+      throw new Error(`unknown doctor option: ${option}`);
+    }
+  }
+}
+
+export async function runDoctor(options: {
+  isJson: boolean;
+  context: ResolvedContext;
+  adapter: ContextAdapter;
+  args?: readonly string[];
+}): Promise<void> {
+  parseDoctorArgs(options.args ?? []);
+  if (options.context.type === "remote") {
+    const context = options.context;
+    const [status, caps] = await Promise.all([
+      options.adapter.configStatus(),
+      options.adapter.getCapabilities(),
+    ]);
+    const remoteReport = {
+      target: context.name || context.server,
+      server: context.server,
+      version: status.version,
+      deployment_runtime: status.deployment_runtime,
+      image_variant: status.image_variant ?? null,
+      runtime: status.runtime,
+      readiness: status.readiness,
+      active_revision: status.active_revision,
+      capabilities: caps,
+      restart_required_keys: status.restart_required_keys,
+      last_reload_error: status.last_reload_error,
+    };
+    emitSuccess({ isJson: options.isJson, target: options.context }, remoteReport, () => {
+      renderContextBanner(options.context);
+      console.log(`server: ${remoteReport.server}`);
+      console.log(`version: ${remoteReport.version}`);
+      console.log(`deployment runtime: ${remoteReport.deployment_runtime}`);
+      console.log(`image variant: ${remoteReport.image_variant ?? "none"}`);
+      console.log(`runtime: ${remoteReport.runtime}`);
+      console.log(`readiness: ${remoteReport.readiness.status} (${remoteReport.readiness.capability})`);
+      console.log(`active revision: ${remoteReport.active_revision}`);
+      console.log(`persistence: ${caps.persistence}`);
+      console.log(`config read: ${caps.config_read}`);
+      console.log(`config write: ${caps.config_write}`);
+      if (status.last_reload_error) {
+        console.log(`last reload error: ${status.last_reload_error}`);
+      }
+      if (status.restart_required_keys.length > 0) {
+        console.log(`restart required for: ${status.restart_required_keys.join(", ")}`);
+      }
+    });
+    return;
+  }
+
+  const effective = await getEffectiveConfig(resolveConfigPath());
+  const report = await diagnose(effective.effective, process.env, effective.sources);
+  emitSuccess({ isJson: options.isJson }, report, () => {
+    console.log(`version: ${report.version}`);
+    console.log(`runtime: ${report.runtime}`);
+    console.log(`image variant: ${report.image_variant ?? "none"}`);
+    console.log(`vault path: ${report.vault_path}`);
+    console.log(`state directory: ${report.state_dir}`);
+    console.log(`inference mode: ${report.mode}`);
+    console.log(`routing capability: ${report.capability}`);
+    console.log(`retrieval capability: ${report.retrieval_capability}`);
+    for (const check of report.checks)
+      console.log(
+        `${check.ok ? green("ok") : red("fail")}: ${check.name} - ${check.detail}`,
+      );
+  });
+  if (report.checks.some((check) => !check.ok)) process.exitCode = 1;
+}

package/src/commands/eval.ts

@@ -1,54 +1,61 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { expandHome, loadConfig } from "../config";
-import { openAudit } from "../db";
-import { buildPromotedCases, excludeExistingCases, parseEvalCases, queryPromotableFetches } from "../eval";
-import { emitSuccess } from "../output";
+import { excludeExistingCases, parseEvalCases } from "../eval";
+import { emitSuccess, warn } from "../output";
 import { parseSince } from "../stats";
 import { confirmIfNeeded } from "./shared";
+import type { ContextAdapter } from "../adapters";
+import { isGlobalFlag, isGlobalFlagWithValue } from "../global-flags";
 
 export async function runEvalPromote(
   args: string[],
-  options: { isJson: boolean; dryRun: boolean },
+  options: { isJson: boolean; dryRun: boolean; adapter: ContextAdapter },
 ): Promise<void> {
   let since: string | undefined;
+  let out: string | undefined;
   let target: string | undefined;
   let dryRun = options.dryRun;
   let yes = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--since") since = args[++i];
+    else if (arg === "--out") out = args[++i];
     else if (arg === "--target") target = args[++i];
     else if (arg === "--dry-run") dryRun = true;
     else if (arg === "--yes") yes = true;
-    else if (arg === "--json") {
+    else if (isGlobalFlag(arg, "--json", "--allow-insecure", "--verbose")) {
       // handled globally by main()'s isJson flag; recognized here so it isn't rejected
+    } else if (isGlobalFlagWithValue(arg)) {
+      i++; // skip flag value
     } else if (arg?.startsWith("--")) {
       throw new Error(`unknown eval promote option: ${arg}`);
     }
   }
   if (!since) {
-    throw new Error("usage: skillmux eval promote --since <window> [--target <path>] [--dry-run] [--yes] [--json]");
+    throw new Error("usage: skillmux eval promote --since <window> [--out <path>] [--dry-run] [--yes] [--json]");
+  }
+
+  if (out !== undefined && target !== undefined && out !== target) {
+    throw new Error("cannot specify conflicting --out and --target");
+  }
+
+  if (target !== undefined) {
+    warn("--target is deprecated, use --out instead");
   }
 
   const config = await loadConfig();
   const stateDir = expandHome(config.state_dir);
-  const targetPath = target ?? join(stateDir, "eval-observed.json");
+  const targetPath = out ?? target ?? join(stateDir, "eval-observed.json");
   const sinceDate = parseSince(since);
   const sinceIso = sinceDate.toISOString();
 
-  const db = openAudit(stateDir);
-  let candidates: ReturnType<typeof buildPromotedCases>;
-  try {
-    candidates = buildPromotedCases(queryPromotableFetches(db, sinceIso));
-  } finally {
-    db.close();
-  }
+  const candidates = await options.adapter.evalPromote(since);
 
   const existing = existsSync(targetPath) ? parseEvalCases(JSON.parse(readFileSync(targetPath, "utf-8"))) : [];
   const { cases: newCases, skipped } = excludeExistingCases(candidates, existing);
 
-  console.error("warning: promoted eval cases contain raw user queries");
+  warn("promoted eval cases contain raw user queries");
 
   if (dryRun) {
     emitSuccess(