aact 3.0.0-beta.3 → 3.0.0-beta.5

package/dist/chunks/index.mjs

@@ -209,7 +209,23 @@ const filterElements = (elements) => {
 const TAGS_MARKER = "__aact_tags__:";
 const LINK_MARKER = "__aact_link__:";
 const SPRITE_MARKER = "__aact_sprite__:";
-const preTransformNamedArgs = (raw) => raw.replaceAll(/, \$tags="(.+?)"/g, `, "${TAGS_MARKER}$1"`).replaceAll(/, \$link="(.+?)"/g, `, "${LINK_MARKER}$1"`).replaceAll(/, \$sprite="(.+?)"/g, `, "${SPRITE_MARKER}$1"`).replaceAll('""', '" "');
+const INDEX_MARKER = "__aact_index__:";
+const preTransformNamedArgs = (raw) => raw.replaceAll(/, \$tags="(.+?)"/g, `, "${TAGS_MARKER}$1"`).replaceAll(/, \$link="(.+?)"/g, `, "${LINK_MARKER}$1"`).replaceAll(/, \$sprite="(.+?)"/g, `, "${SPRITE_MARKER}$1"`).replaceAll(
+  /, \$index=(?:"([^"]+)"|([^,)\s]+))/g,
+  (_match, quoted, bare) => `, "${INDEX_MARKER}${quoted ?? bare ?? ""}"`
+).replaceAll('""', '" "');
+const COMPONENT_BOUNDARY_ALIAS_RE = /\bComponent_Boundary\(\s*([A-Za-z0-9_.]+)/g;
+const preTransform = (raw) => {
+  const componentBoundaryAliases = /* @__PURE__ */ new Set();
+  for (const match of raw.matchAll(COMPONENT_BOUNDARY_ALIAS_RE)) {
+    componentBoundaryAliases.add(match[1]);
+  }
+  const source = preTransformNamedArgs(raw).replaceAll(
+    /\bComponent_Boundary\(/g,
+    "Container_Boundary("
+  );
+  return { source, componentBoundaryAliases };
+};
 const stripMarker = (value, marker) => value && value.startsWith(marker) ? value.slice(marker.length) : void 0;
 const extractMarked = (marker, ...slots) => {
   for (const slot of slots) {
@@ -234,7 +250,7 @@ const normalizeRelBack = (elements) => {
     }
   }
 };
-const ALL_MARKERS = [TAGS_MARKER, LINK_MARKER, SPRITE_MARKER];
+const ALL_MARKERS = [TAGS_MARKER, LINK_MARKER, SPRITE_MARKER, INDEX_MARKER];
 const buildContainer = (el) => {
   const macroKind = parseC4MacroKind(el.type_.name);
   const kind = macroKind?.kind ?? "Container";
@@ -278,30 +294,18 @@ const buildContainer = (el) => {
   };
 };
 const buildRelation = (rel) => {
-  const taggedValue = extractMarked(
-    TAGS_MARKER,
-    rel.techn,
-    rel.descr,
-    rel.sprite,
-    rel.tags,
-    rel.link
-  );
-  const linkValue = extractMarked(
-    LINK_MARKER,
-    rel.techn,
-    rel.descr,
-    rel.sprite,
-    rel.tags,
-    rel.link
-  );
-  const spriteNamedValue = extractMarked(
-    SPRITE_MARKER,
+  const relSlots = [
     rel.techn,
     rel.descr,
     rel.sprite,
     rel.tags,
     rel.link
-  );
+  ];
+  const taggedValue = extractMarked(TAGS_MARKER, ...relSlots);
+  const linkValue = extractMarked(LINK_MARKER, ...relSlots);
+  const spriteNamedValue = extractMarked(SPRITE_MARKER, ...relSlots);
+  const indexValue = extractMarked(INDEX_MARKER, ...relSlots);
+  const order = indexValue !== void 0 && Number.isFinite(Number(indexValue)) ? Number(indexValue) : void 0;
   return {
     to: rel.to,
     description: cleanSlot(rel.label, ...ALL_MARKERS) || void 0,
@@ -310,16 +314,18 @@ const buildRelation = (rel) => {
       cleanSlot(rel.descr, ...ALL_MARKERS) || cleanSlot(rel.tags, ...ALL_MARKERS)
     ) : parseCsvTags(taggedValue),
     sprite: spriteNamedValue ?? cleanSlot(rel.sprite, ...ALL_MARKERS),
-    link: linkValue ?? cleanSlot(rel.link, ...ALL_MARKERS)
+    link: linkValue ?? cleanSlot(rel.link, ...ALL_MARKERS),
+    order
   };
 };
-const buildBoundary = (el, childContainers, childBoundaries) => {
+const buildBoundary = (el, childContainers, childBoundaries, componentBoundaryAliases) => {
   const taggedValue = extractMarked(TAGS_MARKER, el.tags, el.link);
   const linkValue = extractMarked(LINK_MARKER, el.tags, el.link);
+  const kind = componentBoundaryAliases.has(el.alias) ? "Component" : parseBoundaryMacro(el.type_.name);
   return {
     name: el.alias,
     label: el.label,
-    kind: parseBoundaryMacro(el.type_.name),
+    kind,
     tags: taggedValue === void 0 ? parseCsvTags(cleanSlot(el.tags, ...ALL_MARKERS)) : parseCsvTags(taggedValue),
     containerNames: childContainers,
     boundaryNames: childBoundaries,
@@ -371,7 +377,7 @@ const collectChildBoundaryNames = (boundaryElements) => {
 const load = async (filePath) => {
   const filepath = path.resolve(filePath);
   const raw = await fs.readFile(filepath, "utf8");
-  const transformed = preTransformNamedArgs(raw);
+  const { source: transformed, componentBoundaryAliases } = preTransform(raw);
   const [{ elements: rawElements }] = parse(transformed);
   const elements = filterElements(rawElements);
   normalizeRelBack(elements);
@@ -388,7 +394,12 @@ const load = async (filePath) => {
   const childOfBoundary = collectChildBoundaryNames(boundaryElements);
   const boundaries = boundaryElements.map((b) => {
     const { containers, boundaries: childBoundaries } = collectBoundaryChildren(b);
-    return buildBoundary(b, containers, childBoundaries);
+    return buildBoundary(
+      b,
+      containers,
+      childBoundaries,
+      componentBoundaryAliases
+    );
   });
   const rootBoundaryNames = boundaries.map((b) => b.name).filter((name) => !childOfBoundary.has(name));
   return buildModel({

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.3";
+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.3",
+  "version": "3.0.0-beta.5",
   "type": "module",
   "description": "Architecture analysis and compliance tool",
   "keywords": [