@klhapp/skillmux 1.12.0 → 1.13.0

package/src/commands/scan.ts

@@ -1,71 +0,0 @@
-import { expandHome, loadConfig } from "../config";
-import { emitSuccess, warn } from "../output";
-import {
-  parseFailOn,
-  renderScanJson,
-  renderScanText,
-  scanExitCode,
-  scanPath,
-  type ScanSeverity,
-} from "../scan";
-import { isGlobalFlag } from "../global-flags";
-
-function parseScanArgs(args: string[]): {
-  path?: string;
-  format: "text" | "json";
-  formatExplicit: boolean;
-  failOn?: ScanSeverity;
-} {
-  let path: string | undefined;
-  let format: "text" | "json" = "text";
-  let formatExplicit = false;
-  let failOn: ScanSeverity | undefined;
-  for (let i = 0; i < args.length; i++) {
-    const option = args[i];
-    if (option === "--format") {
-      const value = args[++i];
-      if (value !== "text" && value !== "json")
-        throw new Error("--format must be text or json");
-      format = value;
-      formatExplicit = true;
-    } else if (option === "--fail-on") {
-      // scan accepts "none" for symmetry with install/update, where it is the
-      // opt-out. Here it is already the default: scan reports, and the caller
-      // opts into a non-zero exit code.
-      const parsed = parseFailOn(args[++i]);
-      failOn = parsed === "none" ? undefined : parsed;
-    } else if (isGlobalFlag(option, "--json")) {
-      // handled globally by main()'s isJson flag; recognized here so it isn't rejected
-    } else if (option?.startsWith("--")) {
-      throw new Error(`unknown scan option: ${option}`);
-    } else if (path !== undefined) {
-      throw new Error("skillmux scan accepts at most one <path> argument");
-    } else {
-      path = option;
-    }
-  }
-  return { path, format, formatExplicit, failOn };
-}
-
-export async function runScan(
-  args: string[],
-  options: { isJson: boolean },
-): Promise<void> {
-  const { path, format, formatExplicit, failOn } = parseScanArgs(args);
-  if (formatExplicit) {
-    // --format predates the shared --json envelope and is the last command
-    // flag that emits JSON outside it. Kept working for existing callers;
-    // the warning goes to stderr so stdout stays machine-parseable.
-    warn("--format is deprecated and will be removed in a future 1.x release; use --json instead");
-  }
-  const rootPath = path
-    ? expandHome(path)
-    : expandHome((await loadConfig()).vault_path);
-  const result = await scanPath(rootPath);
-  emitSuccess({ isJson: options.isJson }, result, () => {
-    console.log(
-      format === "json" ? renderScanJson(result) : renderScanText(result),
-    );
-  });
-  process.exitCode = scanExitCode(result.findings, failOn);
-}

package/src/commands/shared.ts

@@ -1,38 +0,0 @@
-import { expandHome, loadConfig } from "../config";
-import { parseManifest, resolveManifestPath } from "../manifest";
-import { isInteractive } from "../output";
-import { askQuestion, type PromptIO } from "../prompts";
-
-export async function confirmAction(
-  prompt: string,
-  io: PromptIO = {},
-): Promise<boolean> {
-  const answer = (await askQuestion(`${prompt} [y/N] `, io)).trim().toLowerCase();
-  return answer === "y" || answer === "yes";
-}
-
-export async function loadManifestContext() {
-  const config = await loadConfig();
-  const vaultPath = expandHome(config.vault_path);
-  const manifestPath = resolveManifestPath(vaultPath);
-  if (!manifestPath) {
-    throw new Error(
-      `no skillmux.toml found at ${vaultPath}; run skillmux init first`,
-    );
-  }
-  const manifest = parseManifest(await Bun.file(manifestPath).text());
-  return { config, vaultPath, manifestPath, manifest };
-}
-
-export async function confirmIfNeeded(opts: {
-  confirmed: boolean;
-  isJson: boolean;
-  prompt: string;
-  nonInteractiveError: string;
-}): Promise<boolean> {
-  if (opts.confirmed) return true;
-  if (opts.isJson || !isInteractive()) {
-    throw new Error(opts.nonInteractiveError);
-  }
-  return confirmAction(opts.prompt);
-}

package/src/commands/skill.ts

@@ -1,33 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { expandHome, loadConfig } from "../config";
-import { unknownSubcommandError } from "../output";
-import { vaultResolutionOrder } from "../vault";
-
-export async function runSkill(subCommand: string, args: string[]): Promise<void> {
-  if (subCommand !== "which") throw unknownSubcommandError("skill", subCommand, ["which"]);
-  await runWhich(args);
-}
-
-async function runWhich(args: string[]): Promise<void> {
-  const skillId = args[0];
-  if (!skillId) {
-    throw new Error(
-      "usage: skillmux skill which <skill_id> (local vault shadow resolution; unrelated to MCP routing)",
-    );
-  }
-  const config = await loadConfig();
-  const vaultPath = expandHome(config.vault_path);
-  const localVaultPaths = config.local_vault_paths.map(expandHome);
-  const roots = vaultResolutionOrder(vaultPath, localVaultPaths).filter(
-    (root) => existsSync(join(root, skillId, "SKILL.md")),
-  );
-  if (roots.length === 0) {
-    console.log(`${skillId}: not found in vault_path or local_vault_paths`);
-    process.exitCode = 1;
-    return;
-  }
-  console.log(`${skillId}: serving from ${roots[0]}`);
-  for (const shadowedRoot of roots.slice(1))
-    console.log(`  shadows: ${shadowedRoot}`);
-}

package/src/commands/sync.ts

@@ -1,233 +0,0 @@
-import { existsSync } from "node:fs";
-import { hostname } from "node:os";
-import { expandHome, loadConfig } from "../config";
-import {
-  parseManifest,
-  resolveManifestPath,
-  validateManifest,
-  resolveTargetDir,
-} from "../manifest";
-import { emitSuccess, isInteractive, warn } from "../output";
-import {
-  installPostMergeHook,
-  resolveProjectPinDir,
-  restoreMonolith as restoreMonolithTarget,
-  syncProjectTargets,
-  syncTarget,
-  type ProjectGroupInput,
-} from "../sync";
-import { confirmAction } from "./shared";
-
-function parseSyncArgs(args: string[]): {
-  dryRun: boolean;
-  restoreMonolith: boolean;
-  installHook: boolean;
-  yes: boolean;
-  isJson: boolean;
-} {
-  let dryRun = false;
-  let restoreMonolith = false;
-  let installHook = false;
-  let yes = false;
-  let isJson = false;
-  for (const arg of args) {
-    if (arg === "--dry-run") dryRun = true;
-    else if (arg === "--restore-monolith") restoreMonolith = true;
-    else if (arg === "--install-hook") installHook = true;
-    else if (arg === "--yes") yes = true;
-    else if (arg === "--json") isJson = true;
-    else throw new Error(`unknown sync option: ${arg}`);
-  }
-  return { dryRun, restoreMonolith, installHook, yes, isJson };
-}
-
-/**
- * A target directory that doesn't exist yet is about to be created by `sync`.
- * `manifest.targets[*].dir` is vault content — readable and writable by whatever
- * populated the vault (a shared git-backed vault pulled in, or a hand-edit) — and
- * `sync` can run unattended via the `--install-hook` post-merge hook. Without this
- * gate, a tampered manifest naming a brand-new path gets that directory silently
- * created (and populated with symlinks) the next time anyone pulls. Creation for
- * an as-yet-unseen directory therefore requires either `--yes` or an interactive
- * confirmation; once the directory exists, later syncs never hit this path again.
- */
-async function confirmNewSyncTarget(
-  label: string,
-  dir: string,
-  yes: boolean,
-  isJson: boolean,
-): Promise<boolean> {
-  if (yes) return true;
-  if (!isInteractive()) {
-    if (!isJson) {
-      console.log(
-        `${label}: skipped — ${dir} does not exist yet; creating it requires approval. Re-run "skillmux sync --yes", or run "skillmux sync" interactively, once you've confirmed this target is expected.`,
-      );
-    }
-    return false;
-  }
-  return confirmAction(`${label}: create new target directory ${dir}?`);
-}
-
-interface SyncTargetSummary {
-  target: string;
-  status:
-    | "synced"
-    | "skipped_host_mismatch"
-    | "restored"
-    | "not_owned"
-    | "skipped_not_approved";
-  added?: string[];
-  removed?: string[];
-  skipped?: string[];
-  projects?: {
-    group: string;
-    pin_dir: string;
-    added: string[];
-    removed: string[];
-    skipped: string[];
-  }[];
-}
-
-export async function runSync(args: string[]): Promise<void> {
-  const { dryRun, restoreMonolith, installHook, yes, isJson } = parseSyncArgs(args);
-  const config = await loadConfig();
-  const vaultPath = expandHome(config.vault_path);
-  const log = (line: string) => {
-    if (!isJson) console.log(line);
-  };
-  const warnLine = (line: string) => {
-    if (!isJson) warn(line);
-  };
-
-  let hookInstalled: boolean | undefined;
-  if (installHook) {
-    const result = installPostMergeHook(vaultPath);
-    hookInstalled = result.installed;
-    log(result.installed ? "installed post-merge hook" : "post-merge hook already installed");
-  }
-
-  const manifestPath = resolveManifestPath(vaultPath);
-  if (!manifestPath) {
-    emitSuccess({ isJson }, { hook_installed: hookInstalled ?? null, targets: [] }, () =>
-      console.log("no skillmux.toml found at vault root — nothing to sync"),
-    );
-    return;
-  }
-
-  const manifest = parseManifest(await Bun.file(manifestPath).text());
-  const localVaultPaths = config.local_vault_paths.map(expandHome);
-  const { notes } = validateManifest(manifest, vaultPath, localVaultPaths);
-  for (const note of notes) log(`note: ${note}`);
-
-  const currentHost = hostname();
-  const targetSummaries: SyncTargetSummary[] = [];
-  for (const [targetName, target] of Object.entries(manifest.targets)) {
-    if (target.host !== undefined && target.host !== currentHost) {
-      log(
-        `${targetName}: skipped (host ${target.host} does not match current host ${currentHost})`,
-      );
-      targetSummaries.push({ target: targetName, status: "skipped_host_mismatch" });
-      continue;
-    }
-    const targetDir = resolveTargetDir(targetName, target);
-
-    if (restoreMonolith) {
-      const result = restoreMonolithTarget(targetDir, vaultPath);
-      log(
-        result.restored
-          ? `${targetName}: restored to a vault symlink`
-          : `${targetName}: not owned by skillmux, left untouched`,
-      );
-      targetSummaries.push({
-        target: targetName,
-        status: result.restored ? "restored" : "not_owned",
-      });
-      continue;
-    }
-
-    if (!dryRun && !existsSync(targetDir)) {
-      const approved = await confirmNewSyncTarget(targetName, targetDir, yes, isJson);
-      if (!approved) {
-        if (isInteractive()) {
-          log(`${targetName}: skipped — creating ${targetDir} was not approved`);
-        }
-        targetSummaries.push({ target: targetName, status: "skipped_not_approved" });
-        continue;
-      }
-    }
-
-    const suffix = dryRun ? " (dry-run)" : "";
-    const result = syncTarget(
-      {
-        vaultPath,
-        targetDir,
-        targetName,
-        coreSkillIds: manifest.core.skills,
-        localVaultPaths,
-      },
-      { dryRun },
-    );
-    log(`${targetName}: +${result.added.length} -${result.removed.length}${suffix}`);
-    if (result.skipped.length > 0) {
-      warnLine(`refused to sync ${result.skipped.join(", ")} — skill directory contains a symlink`);
-    }
-    const summary: SyncTargetSummary = {
-      target: targetName,
-      status: "synced",
-      added: result.added,
-      removed: result.removed,
-      skipped: result.skipped,
-    };
-
-    if (target.project_groups.length > 0) {
-      const allGroups = manifest.project ?? {};
-      const projectGroups: Record<string, ProjectGroupInput> = {};
-      for (const groupName of target.project_groups) {
-        const group = allGroups[groupName]!;
-        const approvedPaths: string[] = [];
-        for (const path of group.paths) {
-          // Mirror syncProjectTargets' own `if (!existsSync(path)) continue` so we
-          // never prompt for a project path it would silently skip anyway.
-          if (!existsSync(path)) continue;
-          const pinDir = resolveProjectPinDir(targetDir, path);
-          if (dryRun || existsSync(pinDir)) {
-            approvedPaths.push(path);
-            continue;
-          }
-          const approved = await confirmNewSyncTarget(`${targetName}/${groupName}`, pinDir, yes, isJson);
-          if (approved) approvedPaths.push(path);
-        }
-        projectGroups[groupName] = { ...group, paths: approvedPaths };
-      }
-      const projectResults = syncProjectTargets(
-        { vaultPath, targetDir, targetName, projectGroups, localVaultPaths },
-        { dryRun },
-      );
-      summary.projects = projectResults.map((projectResult) => ({
-        group: projectResult.group,
-        pin_dir: projectResult.pinDir,
-        added: projectResult.added,
-        removed: projectResult.removed,
-        skipped: projectResult.skipped,
-      }));
-      for (const projectResult of projectResults) {
-        log(
-          `  ${projectResult.group} -> ${projectResult.pinDir}: +${projectResult.added.length} -${projectResult.removed.length}${suffix}`,
-        );
-        if (projectResult.skipped.length > 0) {
-          warnLine(
-            `refused to sync ${projectResult.skipped.join(", ")} — skill directory contains a symlink`,
-          );
-        }
-      }
-    }
-    targetSummaries.push(summary);
-  }
-
-  emitSuccess(
-    { isJson },
-    { hook_installed: hookInstalled ?? null, notes, targets: targetSummaries },
-    () => {},
-  );
-}

package/src/commands/target.ts

@@ -1,225 +0,0 @@
-import { existsSync } from "node:fs";
-import { hostname } from "node:os";
-import { expandHome } from "../config";
-import {
-  BUILT_IN_TARGET_NAMES,
-  planAgentSurfaces,
-  resolveBuiltInTarget,
-  SUPPORTED_AGENT_IDS,
-} from "../init-agents";
-import { planInitManifest, applyInit } from "../init";
-import { resolveTargetDir, writeManifestAtomic } from "../manifest";
-import { emitSuccess, unknownSubcommandError } from "../output";
-import { applyTargetMarkerRehome, planTargetMarkerRehome, resolveProjectPinDir } from "../sync";
-import { confirmIfNeeded, loadManifestContext } from "./shared";
-
-export async function runTarget(
-  subCommand: string,
-  args: string[],
-  options: { isJson: boolean; dryRun: boolean },
-): Promise<void> {
-  const { config, 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 agents = SUPPORTED_AGENT_IDS.filter((agent) => {
-        const surface = planAgentSurfaces([agent]).surfaces[0];
-        return surface !== undefined && surface.path === resolveTargetDir(name, target);
-      });
-      return { name, ...target, dir: resolveTargetDir(name, target), agents };
-    });
-    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(`  agents: ${target.agents.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)
-      throw new Error("usage: skillmux target add <name> --dir <dir> --yes");
-
-    let path: string;
-    if (rawPath) {
-      path = expandHome(rawPath);
-    } else if (BUILT_IN_TARGET_NAMES.has(name)) {
-      path = resolveBuiltInTarget(name, {
-        codexHome: process.env.CODEX_HOME ? expandHome(process.env.CODEX_HOME) : undefined,
-      }).path;
-    } else {
-      throw new Error(
-        "usage: skillmux target add <name> --dir <dir> --yes  (--dir may be omitted for built-in target names: agent-skills, claude-code, codex)",
-      );
-    }
-    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 }]);
-    emitSuccess({ isJson: options.isJson }, { 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) {
-      emitSuccess(
-        { isJson: options.isJson },
-        { name, preserved_dir: resolveTargetDir(name, manifest.targets[name]!) },
-        () => 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 };
-    const removedDir = resolveTargetDir(name, manifest.targets[name]!);
-    delete targets[name];
-    writeManifestAtomic(manifestPath, { ...manifest, targets });
-    emitSuccess(
-      { isJson: options.isJson },
-      { name, preserved_dir: removedDir },
-      () =>
-        console.log(
-          `target "${name}" removed from the manifest; files preserved at ${removedDir}`,
-        ),
-    );
-    return;
-  }
-
-  if (subCommand === "rehome") {
-    const name = args[0];
-    const target = name ? manifest.targets[name] : undefined;
-    if (!name || !target) {
-      throw new Error(name ? `target "${name}" does not exist` : "usage: skillmux target rehome <name> --yes");
-    }
-    if (target.host !== undefined && target.host !== hostname()) {
-      throw new Error(`target "${name}" is scoped to host ${target.host}, not ${hostname()}`);
-    }
-
-    const targetDir = resolveTargetDir(name, target);
-    if (!existsSync(targetDir)) throw new Error(`target "${name}" directory does not exist: ${targetDir}`);
-    const dirs = [targetDir];
-    for (const groupName of target.project_groups) {
-      const group = manifest.project?.[groupName];
-      if (!group) continue;
-      for (const projectPath of group.paths) {
-        if (!existsSync(projectPath)) continue;
-        const pinDir = resolveProjectPinDir(targetDir, projectPath);
-        if (existsSync(pinDir)) dirs.push(pinDir);
-      }
-    }
-    const plans = dirs.map((dir) =>
-      planTargetMarkerRehome(dir, name, vaultPath, config.local_vault_paths.map(expandHome)),
-    );
-    const markerPaths = plans.map((plan) => plan.markerPath);
-    if (options.dryRun) {
-      emitSuccess(
-        { isJson: options.isJson },
-        { name, marker_paths: markerPaths },
-        () => console.log(`target rehome: ${name} (${markerPaths.length} markers, dry-run)`),
-      );
-      return;
-    }
-    if (
-      !(await confirmIfNeeded({
-        confirmed: args.includes("--yes"),
-        isJson: options.isJson,
-        prompt: `rehome ${markerPaths.length} ${name} marker(s) to ${vaultPath}?`,
-        nonInteractiveError: "skillmux target rehome requires --yes when run non-interactively",
-      }))
-    )
-      return;
-    applyTargetMarkerRehome(plans, vaultPath);
-    emitSuccess(
-      { isJson: options.isJson },
-      { name, marker_paths: markerPaths },
-      () => console.log(`target "${name}" rehomed ${markerPaths.length} marker(s) to ${vaultPath}`),
-    );
-    return;
-  }
-
-  if (subCommand === "migrate") {
-    const builtInTargets = Object.entries(manifest.targets).filter(([name]) =>
-      BUILT_IN_TARGET_NAMES.has(name),
-    );
-    if (options.dryRun) {
-      emitSuccess(
-        { isJson: options.isJson },
-        { migrated_targets: builtInTargets.map(([name]) => name) },
-        () => console.log(`target migrate: ${builtInTargets.length} built-in target(s) (dry-run)`),
-      );
-      return;
-    }
-    if (
-      !(await confirmIfNeeded({
-        confirmed: args.includes("--yes"),
-        isJson: options.isJson,
-        prompt: `remove redundant dir fields from ${builtInTargets.length} built-in target(s)?`,
-        nonInteractiveError: "skillmux target migrate requires --yes when run non-interactively",
-      }))
-    )
-      return;
-    writeManifestAtomic(manifestPath, manifest);
-    emitSuccess(
-      { isJson: options.isJson },
-      { migrated_targets: builtInTargets.map(([name]) => name) },
-      () => console.log(`target migrate: normalized ${builtInTargets.length} built-in target(s)`),
-    );
-    return;
-  }
-
-  throw unknownSubcommandError("target", subCommand, ["list", "show", "add", "remove", "rehome", "migrate"]);
-}