@klhapp/skillmux 1.0.0 → 1.0.1

package/src/commands/target.ts

@@ -0,0 +1,110 @@
+import { expandHome } from "../config";
+import { planClientSurfaces, SUPPORTED_CLIENT_IDS } from "../init-clients";
+import { planInitManifest, applyInit } from "../init";
+import { writeManifestAtomic } from "../manifest";
+import { emitSuccess } from "../output";
+import { confirmIfNeeded, loadManifestContext } from "./shared";
+export async function runTarget(
+  subCommand: string,
+  args: string[],
+  options: { isJson: boolean; dryRun: boolean },
+): Promise<void> {
+  const { vaultPath, manifestPath, manifest } = await loadManifestContext();
+
+  if (subCommand === "list" || subCommand === "show") {
+    const names =
+      subCommand === "show" ? [args[0] ?? ""] : Object.keys(manifest.targets);
+    if (subCommand === "show" && !manifest.targets[names[0]!]) {
+      throw new Error(`target "${names[0]}" does not exist`);
+    }
+    const targets = names.map((name) => {
+      const target = manifest.targets[name]!;
+      const clients = SUPPORTED_CLIENT_IDS.filter((client) => {
+        const surface = planClientSurfaces([client]).surfaces[0];
+        return surface !== undefined && surface.path === expandHome(target.dir);
+      });
+      return { name, ...target, clients };
+    });
+    emitSuccess({ isJson: options.isJson }, { targets }, () => {
+      if (targets.length === 0) {
+        console.log("no targets configured");
+      } else {
+        for (const target of targets) {
+          console.log(`${target.name}:`);
+          console.log(`  dir: ${target.dir}`);
+          console.log(`  host: ${target.host ?? "(global)"}`);
+          console.log(`  clients: ${target.clients.join(", ") || "(custom)"}`);
+          console.log(
+            `  projects: ${target.project_groups.join(", ") || "(none)"}`,
+          );
+        }
+      }
+    });
+    return;
+  }
+
+  if (subCommand === "add") {
+    const name = args[0];
+    const dirIndex = args.indexOf("--dir");
+    const rawPath = dirIndex === -1 ? undefined : args[dirIndex + 1];
+    if (!name || !rawPath)
+      throw new Error("usage: skillmux target add <name> --dir <dir> --yes");
+    const path = expandHome(rawPath);
+    if (options.dryRun) {
+      const planned = planInitManifest(vaultPath, [{ name, dir: path }], []);
+      emitSuccess(
+        { isJson: options.isJson },
+        { target: planned.targets[name] },
+        () => console.log(`target add: ${name} -> ${path} (dry-run)`),
+      );
+      return;
+    }
+    if (
+      !(await confirmIfNeeded({
+        confirmed: args.includes("--yes"),
+        isJson: options.isJson,
+        prompt: `Adopt target ${name} at ${path}?`,
+        nonInteractiveError:
+          "skillmux target add requires --yes when run non-interactively",
+      }))
+    )
+      return;
+    applyInit(vaultPath, [{ name, dir: path }]);
+    console.log(`target "${name}" added at ${path}`);
+    return;
+  }
+
+  if (subCommand === "remove") {
+    const name = args[0];
+    if (!name || !manifest.targets[name]) {
+      throw new Error(
+        name
+          ? `target "${name}" does not exist`
+          : "usage: skillmux target remove <name> --yes",
+      );
+    }
+    if (options.dryRun) {
+      console.log(`target remove: ${name} (files preserved, dry-run)`);
+      return;
+    }
+    if (
+      !(await confirmIfNeeded({
+        confirmed: args.includes("--yes"),
+        isJson: options.isJson,
+        prompt: `Remove target ${name} from the manifest and preserve its files?`,
+        nonInteractiveError:
+          "skillmux target remove requires --yes when run non-interactively",
+      }))
+    )
+      return;
+    const targets = { ...manifest.targets };
+    delete targets[name];
+    writeManifestAtomic(manifestPath, { ...manifest, targets });
+    console.log(
+      `target "${name}" removed from the manifest; files preserved at ${manifest.targets[name]!.dir}`,
+    );
+    return;
+  }
+
+  throw new Error("usage: skillmux target <list|show|add|remove>");
+}

package/src/config-mutation.ts

@@ -0,0 +1,65 @@
+import { writeFileSync, renameSync } from "node:fs";
+
+export interface ThresholdsPatchOptions {
+  matchScore: number;
+  matchMargin: number;
+  candidateFloor: number;
+  runId: string;
+}
+
+/**
+ * Remove a TOML section header and all lines until the next section header
+ * (or end of file). Matches exact header string at start of line.
+ */
+export function removeSectionBlock(source: string, header: string): string {
+  const lines = source.split("\n");
+  const out: string[] = [];
+  let skipping = false;
+  for (const line of lines) {
+    const trimmed = line.trimEnd();
+    if (trimmed === header || trimmed.startsWith(header + " ")) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && line.trimStart().startsWith("[")) {
+      skipping = false;
+    }
+    if (!skipping) out.push(line);
+  }
+  return out.join("\n");
+}
+
+/**
+ * Surgically patch a TOML string to set [inference.thresholds] values and
+ * [inference.calibration] run_id while preserving unrelated sections and comments.
+ */
+export function patchToml(
+  source: string,
+  opts: ThresholdsPatchOptions,
+): string {
+  const thresholdsBlock = `[inference.thresholds]\nmatch_score = ${opts.matchScore}\nmatch_margin = ${opts.matchMargin}\ncandidate_floor = ${opts.candidateFloor}\n`;
+  const calibrationBlock = `[inference.calibration]\nrun_id = "${opts.runId}"\n`;
+
+  // Remove any existing [inference.thresholds] and [inference.calibration] sections
+  let result = removeSectionBlock(source, "[inference.thresholds]");
+  result = removeSectionBlock(result, "[inference.calibration]");
+
+  // Append both sections cleanly
+  result = result.trimEnd() + "\n\n" + thresholdsBlock + "\n" + calibrationBlock;
+  return result;
+}
+
+/**
+ * Atomically write patched TOML to disk via temp file write and renameSync.
+ */
+export async function patchTomlFile(
+  tomlPath: string,
+  opts: ThresholdsPatchOptions,
+): Promise<void> {
+  const existing = await Bun.file(tomlPath).text();
+  const patched = patchToml(existing, opts);
+
+  const tmpPath = `${tomlPath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, patched);
+  renameSync(tmpPath, tomlPath);
+}