agentic-team 6.1.0 → 6.2.0

package/bin/platforms.js

@@ -0,0 +1,510 @@
+// Which platforms a project builds for, and which installed files belong to
+// which platform.
+//
+// An iOS project was getting Next.js, Expo, Hono and Android material: every
+// stack, every skill, every platform's testing rules. The engineer read "never
+// mock the database" and "component tests run in Chromium", and was offered
+// web-testing as a skill. `project.platforms` in config.yml narrows the
+// install to what the project actually is. An empty list installs everything,
+// because /orchestra:setup has not chosen yet.
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const read = (file) => {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    // Optional: an unreadable or missing file is simply not a signal.
+    return "";
+  }
+};
+
+const PLATFORMS = ["web", "expo", "ios", "android", "backend"];
+
+// Every shipped skill is listed. test/platforms.test.js fails on one that is
+// not, so a new skill cannot silently install everywhere.
+const SKILLS = {
+  architecture: "all",
+  "code-optimizer": "all",
+  debug: "all",
+  "error-handling": "all",
+  observability: "all",
+  "project-structure": "all",
+  realtime: "all",
+  review: "all",
+  testing: "all",
+  // Both speak ARIA and CSS today; native iOS and Android have no UI or
+  // accessibility skill yet, and these would teach them the web's answers.
+  accessibility: ["web", "expo"],
+  "frontend-design": ["web", "expo"],
+  "best-practices": ["web"],
+  "core-web-vitals": ["web"],
+  "react-best-practices": ["web"],
+  "web-quality-audit": ["web"],
+  "web-testing": ["web"],
+  // TypeScript and React conventions — every platform written in TypeScript.
+  "fullstack-infrastructure": ["web", "expo", "backend"],
+  "mobile-testing": ["expo"],
+  "ios-testing": ["ios"],
+  "android-testing": ["android"],
+  "push-notifications": ["expo", "ios", "android"],
+  "crud-api": ["backend"],
+  // Health and readiness endpoints, promotion, rollback, migrations: a
+  // service's deploy, and it implements the rule sections only a backend gets.
+  deployment: ["backend"],
+  // The decisions the backend stack scaffolded — sessions, hashing, where the
+  // code lives. On a client it would describe a server that is not there.
+  "auth-setup": ["backend"],
+};
+
+// Keyed by the directory under .orchestra/stacks/. Files directly under it
+// (README.md) and the shared _lib and _repo serve every stack.
+const STACKS = {
+  _lib: "all",
+  _repo: "all",
+  "web-vite-react": ["web"],
+  "web-nextjs": ["web"],
+  "mobile-expo": ["expo"],
+  "mobile-ios-native": ["ios"],
+  "mobile-android-native": ["android"],
+  "backend-hono": ["backend"],
+};
+
+/** "[ios, backend]", "ios,backend" or an array → a trimmed, de-duplicated list. */
+function parsePlatforms(value) {
+  if (Array.isArray(value)) {
+    // Quotes and case are the user's spelling, not a different platform:
+    // `- "iOS"` dropped as unknown once narrowed a project and rewrote its list.
+    const clean = value.map((v) =>
+      String(v)
+        .trim()
+        .replace(/^["']|["']$/g, "")
+        .toLowerCase(),
+    );
+    return [...new Set(clean.filter(Boolean))];
+  }
+  const inner = String(value ?? "")
+    .trim()
+    .replace(/^\[|\]$/g, "");
+  return parsePlatforms(inner.split(",").map((v) => v.trim().replace(/^["']|["']$/g, "")));
+}
+
+/** The tags of one installed path (repo-relative, POSIX), or "all". */
+function tagsFor(rel) {
+  const skill = /^\.claude\/skills\/([^/]+)\//.exec(rel);
+  if (skill) return SKILLS[skill[1]] ?? "all";
+  const stack = /^\.orchestra\/stacks\/([^/]+)\//.exec(rel);
+  if (stack) return STACKS[stack[1]] ?? "all";
+  return "all";
+}
+
+function wanted(tags, platforms) {
+  if (!platforms.length || tags === "all") return true;
+  return tags.some((t) => platforms.includes(t));
+}
+
+/**
+ * Whether an installed path belongs in a project with these platforms. A
+ * skill a milestone phase already names is kept whatever its tags: lead reads
+ * `.claude/skills/{name}/SKILL.md` for every name a phase lists, and a plan
+ * written before the list was narrowed must not lose a skill it relies on.
+ */
+function selected(rel, platforms, keepSkills = new Set()) {
+  const skill = /^\.claude\/skills\/([^/]+)\//.exec(rel);
+  if (skill && keepSkills.has(skill[1])) return true;
+  return wanted(tagsFor(rel), platforms);
+}
+
+/** Every skill name a phase under `.orchestra/milestones/` lists in `skills:`. */
+function phaseSkills(root) {
+  const names = new Set();
+  const milestones = path.join(root, ".orchestra", "milestones");
+  let dirs = [];
+  try {
+    dirs = fs.readdirSync(milestones);
+  } catch {
+    // No milestones yet: no phase names any skill.
+    return names;
+  }
+  for (const m of dirs) {
+    const phases = path.join(milestones, m, "phases");
+    let files = [];
+    try {
+      files = fs.readdirSync(phases).filter((f) => f.endsWith(".md"));
+    } catch {
+      // A milestone without phases yet.
+      continue;
+    }
+    for (const f of files) {
+      const text = read(path.join(phases, f));
+      const flow = /^skills:\s*\[([^\]]*)\]/m.exec(text);
+      if (flow) {
+        for (const n of parsePlatforms(flow[1])) names.add(n);
+        continue;
+      }
+      const block = /^skills:\s*\n((?:\s+-\s*.+\n?)+)/m.exec(text);
+      if (block) {
+        for (const line of block[1].split("\n")) {
+          const item = /^\s+-\s*([^#\s]+)/.exec(line);
+          if (item) names.add(item[1].replace(/^["']|["']$/g, ""));
+        }
+      }
+    }
+  }
+  return names;
+}
+
+/**
+ * The value of `--platforms` in an argument list, and the indexes it used.
+ * Names after the flag, space-separated or after `=`, are all taken until the
+ * next option: "--platforms ios backend" once kept ios and retired backend.
+ * Shared by the install and by `new`, which parsed it differently and took a
+ * platform for the repository name.
+ */
+function takePlatformsArg(argv) {
+  const at = argv.findIndex((a) => a === "--platforms" || a.startsWith("--platforms="));
+  if (at === -1) return null;
+  const parts = argv[at] === "--platforms" ? [] : [argv[at].slice("--platforms=".length)];
+  let i = at + 1;
+  while (i < argv.length && !argv[i].startsWith("-")) parts.push(argv[i++]);
+  return { list: parsePlatforms(parts.join(",")), used: new Set(range(at, i)) };
+}
+
+const range = (from, to) => Array.from({ length: to - from }, (_, k) => from + k);
+
+// A rule section that applies to some platforms only carries a marker on the
+// line before its heading:
+//
+//   <!-- platforms: backend -->
+//   ## Backend — the shape
+//
+// The section runs to the next heading of the same or a higher level. Markers
+// rather than one file per platform, because a dozen files point at
+// `testing-standards.orchestra.md` by name; split, every one of those pointers
+// would have to learn which piece it meant.
+const MARKER = /^<!--\s*platforms:\s*([^>]*?)\s*-->\s*$/;
+const HEADING = /^(#{1,6})\s/;
+
+/** A rule's text with other platforms' sections removed, and markers always removed. */
+function filterSections(text, platforms) {
+  const out = [];
+  let pending = null;
+  let skipLevel = 0;
+  let fence = null;
+  for (const line of text.split("\n")) {
+    // A `#` line inside a code block is a shell comment, not a heading. A
+    // fence closes only on the same character, at least as long — a ````
+    // block may show a ``` one inside it.
+    const f = /^\s*(`{3,}|~{3,})/.exec(line);
+    if (f && (!fence || (f[1][0] === fence[0] && f[1].length >= fence.length))) {
+      fence = fence ? null : f[1];
+      if (!skipLevel) out.push(line);
+      continue;
+    }
+    if (fence) {
+      if (!skipLevel) out.push(line);
+      continue;
+    }
+    const marker = MARKER.exec(line);
+    if (marker) {
+      pending = parsePlatforms(marker[1]);
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      const level = heading[1].length;
+      if (skipLevel && level <= skipLevel) skipLevel = 0;
+      if (pending && !wanted(pending, platforms)) skipLevel = level;
+      pending = null;
+    }
+    if (!skipLevel) out.push(line);
+  }
+  return out.join("\n");
+}
+
+// ── Detection ──────────────────────────────────────────────────────────────
+//
+// Code, not an agent's guess: the same files every time give the same answer,
+// and the installer prints it so a wrong answer is seen and overridden.
+
+const SKIP_DIRS = new Set([
+  "node_modules",
+  "Pods",
+  "build",
+  "dist",
+  "DerivedData",
+  "vendor",
+  "target",
+  "out",
+  "export",
+  "exports",
+  "release",
+  "generated",
+]);
+
+function dependencies(dir) {
+  const text = read(path.join(dir, "package.json"));
+  if (!text) return null;
+  try {
+    const pkg = JSON.parse(text);
+    return { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+  } catch {
+    // A package.json that does not parse says nothing about the platform.
+    return null;
+  }
+}
+
+const has = (deps, names) => names.some((n) => Object.hasOwn(deps, n));
+
+// vite is not on either list: the scaffolded Hono backend carries it as
+// vitest's peer, and a bundler is not a web app until a UI library sits on it.
+const WEB_FRAMEWORKS = [
+  "next",
+  "nuxt",
+  "@sveltejs/kit",
+  "astro",
+  "@angular/core",
+  "@remix-run/react",
+];
+const WEB_UI = ["react-dom", "vue", "svelte", "solid-js", "preact"];
+// A desktop shell renders a UI with the same libraries. Desktop has no pack,
+// so it detects as nothing rather than as web.
+const DESKTOP = ["electron", "@tauri-apps/api", "@tauri-apps/cli"];
+const SERVER = [
+  "hono",
+  "express",
+  "fastify",
+  "koa",
+  "@nestjs/core",
+  "@hapi/hapi",
+  "@trpc/server",
+  "elysia",
+];
+
+const MOBILE_SDK = /SDKROOT = (iphoneos|watchos|xros)|IPHONEOS_DEPLOYMENT_TARGET/;
+// A target's platform key, not any mention: a macOS app's comment may say iOS.
+const XCODEGEN_IOS =
+  /^\s*(platform|supportedDestinations|deploymentTarget):[^\n]*\b(iOS|watchOS|visionOS)\b/m;
+const PY_REQUIREMENT = /^\s*(fastapi|django|flask|starlette)\b/im;
+const PY_PROJECT =
+  /(["'](fastapi|django|flask|starlette)\b|^\s*(fastapi|django|flask|starlette)\s*=)/im;
+
+/** Platforms one directory shows on its own, plus children to leave unscanned. */
+function signals(dir) {
+  const found = new Set();
+  const skip = new Set();
+  const names = (() => {
+    try {
+      return fs.readdirSync(dir);
+    } catch {
+      // Unreadable directory: nothing to detect in it.
+      return [];
+    }
+  })();
+
+  const deps = dependencies(dir);
+  if (deps) {
+    const native = has(deps, ["expo", "react-native"]);
+    if (native) {
+      found.add("expo");
+      // A React Native app carries generated ios/ and android/ projects.
+      // They are its build output, not a second and third app.
+      skip.add("ios");
+      skip.add("android");
+    }
+    // react-dom alone is Expo's web target in a React Native app.
+    const web =
+      native || has(deps, DESKTOP)
+        ? has(deps, WEB_FRAMEWORKS)
+        : has(deps, [...WEB_FRAMEWORKS, ...WEB_UI]);
+    if (web) found.add("web");
+    if (has(deps, SERVER)) found.add("backend");
+  }
+
+  // An Xcode project is iOS only when it builds for an Apple mobile SDK; a
+  // macOS-only app is desktop, which has no pack. watchOS and visionOS ride
+  // along with iOS, which is what the ios stack and skills cover.
+  if (
+    names.some(
+      (n) =>
+        n.endsWith(".xcodeproj") && MOBILE_SDK.test(read(path.join(dir, n, "project.pbxproj"))),
+    ) ||
+    XCODEGEN_IOS.test(read(path.join(dir, "project.yml"))) ||
+    /\.iOS\(/.test(read(path.join(dir, "Package.swift")))
+  ) {
+    found.add("ios");
+  }
+
+  const gradle = ["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"]
+    .map((f) => read(path.join(dir, f)))
+    .join("\n");
+  if (/com\.android|plugins\.android|android\s*\{/.test(gradle)) found.add("android");
+
+  if (names.includes("go.mod")) found.add("backend");
+  // A requirement line starts with the package name; a pyproject names it in
+  // quotes or as a key. Prose that mentions Flask is not a server.
+  if (
+    PY_REQUIREMENT.test(read(path.join(dir, "requirements.txt"))) ||
+    PY_PROJECT.test(read(path.join(dir, "pyproject.toml")))
+  ) {
+    found.add("backend");
+  }
+  if (/\brails\b/.test(read(path.join(dir, "Gemfile")))) found.add("backend");
+  if (/\b(axum|actix-web|rocket)\b/.test(read(path.join(dir, "Cargo.toml")))) found.add("backend");
+
+  // A game engine exports native projects for every target it ships to.
+  // They are build output; game has no pack, so the engine project is nothing.
+  const engine =
+    names.includes("project.godot") ||
+    names.some((n) => n.endsWith(".uproject")) ||
+    (names.includes("Assets") && names.includes("ProjectSettings"));
+  if (engine) return { found: new Set(), skip: new Set(names), names };
+
+  return { found, skip, names };
+}
+
+// Directories that hold something other than the product: a docs site, an
+// example, a fixture. Scanning them reports platforms nobody ships.
+const NOT_APPS = new Set([
+  "docs",
+  "doc",
+  "website",
+  "examples",
+  "example",
+  "samples",
+  "sample",
+  "fixtures",
+  "test",
+  "tests",
+  "__tests__",
+  "e2e",
+  "scripts",
+  "tools",
+  "archive",
+]);
+
+/**
+ * Platforms found in the repository at `root`: the root and two levels of
+ * directories under it (`apps/web`, `clients/ios`), skipping dependencies,
+ * build output and directories that are not the product. Deeper than that is
+ * a guess.
+ */
+function detectPlatforms(root) {
+  const found = new Set();
+  const visit = (dir, depth) => {
+    const s = signals(dir);
+    for (const p of s.found) found.add(p);
+    if (depth === 0) return;
+    for (const name of s.names) {
+      if (name.startsWith(".") || s.skip.has(name)) continue;
+      if (SKIP_DIRS.has(name) || NOT_APPS.has(name.toLowerCase())) continue;
+      const child = path.join(dir, name);
+      let isDir = false;
+      try {
+        isDir = fs.statSync(child).isDirectory();
+      } catch {
+        // A dangling link or a permission error: not a directory to scan.
+      }
+      if (!isDir) continue;
+      visit(child, depth - 1);
+    }
+  };
+  visit(root, 2);
+  return PLATFORMS.filter((p) => found.has(p));
+}
+
+// ── config.yml ─────────────────────────────────────────────────────────────
+
+/** The `project:` block's line range in config.yml text: [start, end). */
+function projectBlock(lines) {
+  const start = lines.findIndex((l) => /^project:\s*(#.*)?$/.test(l));
+  if (start === -1) return null;
+  let end = start + 1;
+  while (end < lines.length && !/^[A-Za-z_]/.test(lines[end])) end++;
+  return [start, end];
+}
+
+/** `project.platforms` from config.yml text — flow or block form. */
+function readConfigPlatforms(text) {
+  const lines = String(text).split("\n");
+  const block = projectBlock(lines);
+  if (!block) {
+    // `project: { platforms: [ios] }` — the merge rewrites it as a block, so
+    // it has to be read here or the user's list is lost to detection.
+    const inline = lines
+      .map((l) => /^project:\s*\{.*\bplatforms:\s*(\[[^\]]*\])/.exec(l))
+      .find(Boolean);
+    return inline ? parsePlatforms(inline[1]) : [];
+  }
+  for (let i = block[0] + 1; i < block[1]; i++) {
+    const m = /^\s+platforms:\s*([^#]*)/.exec(lines[i]);
+    if (!m) continue;
+    let flow = m[1].trim();
+    // A flow list may run over several lines: `[` here, `]` further down.
+    for (let j = i + 1; flow.startsWith("[") && !flow.includes("]") && j < block[1]; j++) {
+      flow += ` ${lines[j].replace(/#.*$/, "").trim()}`;
+    }
+    if (flow) return parsePlatforms(flow);
+    const items = [];
+    for (let j = i + 1; j < block[1]; j++) {
+      const item = /^\s+-\s*([^#\s]+)/.exec(lines[j]);
+      if (item) items.push(item[1]);
+      else if (lines[j].trim() && !lines[j].trim().startsWith("#")) break;
+    }
+    return parsePlatforms(items);
+  }
+  return [];
+}
+
+/**
+ * config.yml text with `project.platforms` set to `list`, in flow form, or
+ * null when `project:` is written in a shape this cannot edit safely (an
+ * inline map) — adding a second `project:` key would make the file invalid.
+ */
+function writeConfigPlatforms(text, list) {
+  const lines = String(text).split("\n");
+  const value = `  platforms: [${list.join(", ")}]`;
+  const block = projectBlock(lines);
+  if (!block) {
+    if (lines.some((l) => /^project:/.test(l))) return null;
+    return [`project:`, value, "", ...lines].join("\n");
+  }
+  for (let i = block[0] + 1; i < block[1]; i++) {
+    if (!/^\s+platforms:/.test(lines[i])) continue;
+    const indent = /^\s*/.exec(lines[i])[0];
+    const comment = /\s+#.*$/.exec(lines[i].replace(/^[^[]*\[[^\]]*\]/, ""))?.[0] ?? "";
+    let end = i + 1;
+    if (/platforms:\s*\[[^\]]*$/.test(lines[i])) {
+      while (end < block[1] && !lines[end - 1].includes("]")) end++;
+    }
+    // A block list, comment lines between its items included.
+    if (/platforms:\s*(#.*)?$/.test(lines[i])) {
+      let last = end - 1;
+      for (let j = end; j < block[1]; j++) {
+        if (/^\s+-\s/.test(lines[j])) last = j;
+        else if (!/^\s*(#.*)?$/.test(lines[j])) break;
+      }
+      end = last + 1;
+    }
+    lines.splice(i, end - i, `${indent}platforms: [${list.join(", ")}]${comment}`);
+    return lines.join("\n");
+  }
+  lines.splice(block[0] + 1, 0, value);
+  return lines.join("\n");
+}
+
+module.exports = {
+  PLATFORMS,
+  SKILLS,
+  STACKS,
+  parsePlatforms,
+  tagsFor,
+  selected,
+  phaseSkills,
+  takePlatformsArg,
+  filterSections,
+  detectPlatforms,
+  readConfigPlatforms,
+  writeConfigPlatforms,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-team",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "AI Team Orchestration System — multi-role coordination for Claude Code",
   "engines": {
     "node": ">=22"
@@ -22,11 +22,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/sulhadin/orchestrator.git"
+    "url": "https://github.com/sulhadin/agentic-team.git"
   },
-  "homepage": "https://github.com/sulhadin/orchestrator/blob/main/docs/README.md",
+  "homepage": "https://github.com/sulhadin/agentic-team/blob/main/docs/README.md",
   "bugs": {
-    "url": "https://github.com/sulhadin/orchestrator/issues"
+    "url": "https://github.com/sulhadin/agentic-team/issues"
   },
   "author": "Sulhadin Öney",
   "license": "MIT",

package/template/.claude-plugin/plugin.json

@@ -1,10 +1,10 @@
 {
   "name": "orchestra",
   "description": "AI Team Orchestration — multi-role coordination with milestones, phases, and quality gates for Claude Code",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "author": {
     "name": "Sulhadin Öney"
   },
-  "repository": "https://github.com/sulhadin/orchestrator",
+  "repository": "https://github.com/sulhadin/agentic-team",
   "license": "MIT"
 }