aact 3.0.0-beta.4 → 3.0.0-beta.5

package/dist/cli/index.mjs

@@ -7,8 +7,10 @@ import path, { basename } from 'pathe';
 import * as v from 'valibot';
 import fs, { readFile, writeFile } from 'node:fs/promises';
 import { colors, box } from 'consola/utils';
+import { execFile } from 'node:child_process';
+import os from 'node:os';
 
-const version = "3.0.0-beta.4";
+const version = "3.0.0-beta.5";
 
 const matchesPattern = (filePath, pattern) => {
   if (pattern.startsWith("*")) {
@@ -708,12 +710,304 @@ const rule = defineCommand({
   subCommands: { list: listAction }
 });
 
+const skillName = "aact-architect";
+const markerFileName = ".aact-skill.json";
+const defaultRepo = "https://github.com/ChS23/aact-architect-skill.git";
+const defaultRef = "main";
+const clientValues = [
+  "shared",
+  "codex",
+  "cursor",
+  "copilot",
+  "claude",
+  "cline",
+  "all"
+];
+const targetLabels = {
+  shared: "Agent Skills",
+  claude: "Claude Code",
+  cline: "Cline"
+};
+const defaultRoots = {
+  shared: "~/.agents/skills",
+  claude: "~/.claude/skills",
+  cline: "~/.cline/skills"
+};
+const sharedClientValues = /* @__PURE__ */ new Set([
+  "shared",
+  "codex",
+  "cursor",
+  "copilot"
+]);
+const defaultRuntime = {
+  git: (args, options) => new Promise((resolve, reject) => {
+    execFile(
+      // eslint-disable-next-line sonarjs/no-os-command-from-path -- This CLI intentionally invokes the user's git binary to clone/update the skill repository.
+      "git",
+      [...args],
+      { cwd: options?.cwd },
+      (error, _stdout, stderr) => {
+        if (error) {
+          const reason = stderr.trim() || error.message;
+          reject(new Error(`git ${args.join(" ")} failed: ${reason}`));
+          return;
+        }
+        resolve();
+      }
+    );
+  }),
+  now: () => /* @__PURE__ */ new Date()
+};
+const isClientValue = (value) => clientValues.includes(value);
+const expandHome = (input) => {
+  if (input === "~") return os.homedir();
+  if (input.startsWith("~/")) return path.join(os.homedir(), input.slice(2));
+  return input;
+};
+const resolveRootDir = (rootOrSkillDir) => {
+  const resolved = path.resolve(expandHome(rootOrSkillDir));
+  return path.basename(resolved) === skillName ? path.dirname(resolved) : resolved;
+};
+const toSkillDir = (rootDir) => path.join(rootDir, skillName);
+const normalizeKind = (client) => {
+  if (client === "all") return ["shared", "claude", "cline"];
+  if (sharedClientValues.has(client)) return ["shared"];
+  if (client === "claude" || client === "cline") return [client];
+  return ["shared"];
+};
+const selectedKinds = (args) => {
+  const out = /* @__PURE__ */ new Set();
+  if (args.all) {
+    for (const kind of normalizeKind("all")) out.add(kind);
+  }
+  if (args.client) {
+    if (!isClientValue(args.client)) {
+      throw new Error(
+        `Unknown skill client "${args.client}". Expected one of: ${clientValues.join(", ")}.`
+      );
+    }
+    for (const kind of normalizeKind(args.client)) out.add(kind);
+  }
+  if (args.codex) out.add("shared");
+  if (args.cursor) out.add("shared");
+  if (args.copilot) out.add("shared");
+  if (args.claude) out.add("claude");
+  if (args.cline) out.add("cline");
+  if (out.size === 0) out.add("shared");
+  return [...out];
+};
+const createInstallPlans = (args) => {
+  const kinds = selectedKinds(args);
+  if (args.target && kinds.length > 1) {
+    throw new Error(
+      "--target can be used with a single client target only. Remove --all or install clients one by one."
+    );
+  }
+  return kinds.map((kind) => {
+    const rootDir = resolveRootDir(args.target ?? defaultRoots[kind]);
+    return {
+      kind,
+      label: targetLabels[kind],
+      rootDir,
+      skillDir: toSkillDir(rootDir)
+    };
+  });
+};
+const pathExists = async (target) => {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const readMarker = async (skillDir) => {
+  try {
+    const content = await fs.readFile(
+      path.join(skillDir, markerFileName),
+      "utf8"
+    );
+    const parsed = JSON.parse(content);
+    if (parsed.managedBy === "aact" && parsed.skill === skillName) {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+};
+const writeMarker = async (plan, repo, ref, runtime) => {
+  const marker = {
+    managedBy: "aact",
+    skill: skillName,
+    client: plan.kind,
+    repo,
+    ref,
+    aactVersion: version,
+    installedAt: runtime.now().toISOString()
+  };
+  await fs.writeFile(
+    path.join(plan.skillDir, markerFileName),
+    JSON.stringify(marker, void 0, 2) + "\n"
+  );
+};
+const ensureSkillFile = async (skillDir) => {
+  const skillFile = path.join(skillDir, "SKILL.md");
+  if (!await pathExists(skillFile)) {
+    throw new Error(
+      `Installed repository does not contain ${skillName}/SKILL.md at ${skillFile}.`
+    );
+  }
+};
+const cloneSkill = async (plan, repo, ref, runtime) => {
+  await fs.mkdir(plan.rootDir, { recursive: true });
+  await runtime.git([
+    "clone",
+    "--depth",
+    "1",
+    "--branch",
+    ref,
+    repo,
+    plan.skillDir
+  ]);
+  await ensureSkillFile(plan.skillDir);
+};
+const updateSkill = async (plan, repo, ref, runtime) => {
+  const marker = await readMarker(plan.skillDir);
+  if (!marker) {
+    throw new Error(
+      `${plan.skillDir} already exists and is not managed by aact. Use --force to overwrite it.`
+    );
+  }
+  if (marker.repo !== repo) {
+    throw new Error(
+      `${plan.skillDir} is managed by aact but was installed from ${marker.repo}. Use --force to reinstall from ${repo}.`
+    );
+  }
+  if (!await pathExists(path.join(plan.skillDir, ".git"))) {
+    throw new Error(
+      `${plan.skillDir} is managed by aact but is not a git checkout. Use --force to reinstall it.`
+    );
+  }
+  await runtime.git(["fetch", "--depth", "1", "origin", ref], {
+    cwd: plan.skillDir
+  });
+  await runtime.git(["checkout", "--force", "FETCH_HEAD"], {
+    cwd: plan.skillDir
+  });
+  await ensureSkillFile(plan.skillDir);
+};
+const installOne = async (plan, args, runtime) => {
+  const repo = args.repo ?? defaultRepo;
+  const ref = args.ref ?? defaultRef;
+  const dryRun = args["dry-run"] ?? false;
+  const force = args.force ?? false;
+  const exists = await pathExists(plan.skillDir);
+  const action = exists ? "update" : "install";
+  if (dryRun) {
+    consola.info(
+      `[dry run] ${force && exists ? "reinstall" : action} ${skillName} for ${plan.label}: ${plan.skillDir}`
+    );
+    return;
+  }
+  if (exists && force) {
+    await fs.rm(plan.skillDir, { recursive: true, force: true });
+  }
+  if (exists && !force) {
+    await updateSkill(plan, repo, ref, runtime);
+    await writeMarker(plan, repo, ref, runtime);
+    consola.success(`Updated ${skillName} for ${plan.label}: ${plan.skillDir}`);
+    return;
+  }
+  await cloneSkill(plan, repo, ref, runtime);
+  await writeMarker(plan, repo, ref, runtime);
+  consola.success(`Installed ${skillName} for ${plan.label}: ${plan.skillDir}`);
+};
+const installAgentSkill = async (args, runtime = defaultRuntime) => {
+  const repo = args.repo ?? defaultRepo;
+  const ref = args.ref ?? defaultRef;
+  const plans = createInstallPlans(args);
+  consola.info(`Installing community ${skillName} skill from ${repo} (${ref})`);
+  for (const plan of plans) {
+    await installOne(plan, args, runtime);
+  }
+};
+const installArgs = {
+  client: {
+    type: "enum",
+    description: "Client target: shared, codex, cursor, copilot, claude, cline, all",
+    options: [...clientValues]
+  },
+  codex: {
+    type: "boolean",
+    description: "Install into the shared ~/.agents/skills path used by Codex"
+  },
+  cursor: {
+    type: "boolean",
+    description: "Install into the shared ~/.agents/skills path used by Cursor"
+  },
+  copilot: {
+    type: "boolean",
+    description: "Install into the shared ~/.agents/skills path used by GitHub Copilot"
+  },
+  claude: {
+    type: "boolean",
+    description: "Install into ~/.claude/skills for Claude Code"
+  },
+  cline: {
+    type: "boolean",
+    description: "Install into ~/.cline/skills for Cline"
+  },
+  all: {
+    type: "boolean",
+    description: "Install shared, Claude Code, and Cline targets"
+  },
+  target: {
+    type: "string",
+    description: "Custom skills root or full skill directory"
+  },
+  repo: {
+    type: "string",
+    description: "Skill repository URL",
+    default: defaultRepo
+  },
+  ref: {
+    type: "string",
+    description: "Git branch or tag to install",
+    default: defaultRef
+  },
+  force: {
+    type: "boolean",
+    description: "Overwrite an existing unmanaged skill directory"
+  },
+  "dry-run": {
+    type: "boolean",
+    description: "Show target directories without writing files"
+  }
+};
+const install = defineCommand({
+  meta: {
+    description: "Install the community aact-architect skill for AI agents"
+  },
+  args: installArgs,
+  async run({ args }) {
+    await installAgentSkill(args);
+  }
+});
+const skill = defineCommand({
+  meta: {
+    description: "Install agent skills for aact workflows"
+  },
+  args: installArgs,
+  default: "install",
+  subCommands: { install }
+});
+
 const main = defineCommand({
   meta: {
     name: "aact",
     version,
     description: "Architecture analysis and compliance tool"
   },
-  subCommands: { init, check, analyze, generate, rule }
+  subCommands: { init, check, analyze, generate, rule, skill }
 });
 void runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aact",
-  "version": "3.0.0-beta.4",
+  "version": "3.0.0-beta.5",
   "type": "module",
   "description": "Architecture analysis and compliance tool",
   "keywords": [