arboris-cli 1.0.0 → 1.1.0

package/dist/cli.mjs

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+// ../../cli/main.ts
+import { resolve as resolve2 } from "node:path";
+
+// ../../src/lib/agents.ts
+var AGENT_SKILL_PATH = {
+  Cursor: (id) => `.cursor/skills/${id}/SKILL.md`,
+  Claude: (id) => `.claude/skills/${id}/SKILL.md`,
+  Codex: (id) => `.agents/skills/${id}/SKILL.md`,
+  Copilot: (id) => `.github/skills/${id}/SKILL.md`
+};
+function isAgentName(name) {
+  return name in AGENT_SKILL_PATH;
+}
+function agentSkillPath(agent, skillId) {
+  return AGENT_SKILL_PATH[agent](skillId);
+}
+
+// ../../src/lib/package-root.ts
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function hasPackageAssets(dir) {
+  if (!existsSync(join(dir, "package.json"))) return false;
+  return existsSync(join(dir, "prisma", "skills")) || existsSync(join(dir, "manifest.json"));
+}
+function resolvePackageRoot(fromModuleUrl) {
+  let dir = dirname(fileURLToPath(fromModuleUrl));
+  for (let i = 0; i < 10; i++) {
+    if (hasPackageAssets(dir)) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return dirname(fileURLToPath(fromModuleUrl));
+}
+function defaultSkillsDir(packageRoot) {
+  return join(packageRoot, "prisma", "skills");
+}
+function defaultManifestPath(packageRoot) {
+  const atRoot = join(packageRoot, "manifest.json");
+  if (existsSync(atRoot)) return atRoot;
+  return join(packageRoot, "cli", "manifest.json");
+}
+
+// ../../src/lib/skill-install-core.ts
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { dirname as dirname2, resolve } from "node:path";
+
+// ../../src/lib/skill-file.ts
+import { readFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+function parseDependsOn(frontmatter) {
+  const lines = frontmatter.split(/\r?\n/);
+  const deps = [];
+  let inDepends = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!inDepends) {
+      if (trimmed === "depends_on:" || trimmed === "dependencies:") {
+        inDepends = true;
+      }
+      continue;
+    }
+    if (!trimmed) continue;
+    if (/^[A-Za-z0-9_-]+:/.test(trimmed)) break;
+    const match = trimmed.match(/^-\s+(.+)$/);
+    if (!match) break;
+    deps.push(match[1].trim());
+  }
+  return deps;
+}
+function parseSkillFile(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    return { dependsOn: [], body: raw.trim(), raw };
+  }
+  const [, frontmatter, body] = match;
+  return {
+    dependsOn: parseDependsOn(frontmatter),
+    body: body.trim(),
+    raw
+  };
+}
+async function readSkillFileByRef(skillsDir, ref) {
+  try {
+    const content = await readFile(join2(skillsDir, ref, "SKILL.md"), "utf-8");
+    return content.trim() ? parseSkillFile(content) : null;
+  } catch {
+    return null;
+  }
+}
+async function compileSkillFile(skillsDir, ref, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(ref)) return null;
+  seen.add(ref);
+  const parsed = await readSkillFileByRef(skillsDir, ref);
+  if (!parsed) return null;
+  const sections = [parsed.body];
+  for (const dep of parsed.dependsOn) {
+    const compiled = await compileSkillFile(skillsDir, dep, seen);
+    if (!compiled) continue;
+    sections.push(`## Included dependency: ${dep}
+
+${compiled}`);
+  }
+  return sections.filter(Boolean).join("\n\n");
+}
+async function loadSkillFileContent(skillsDir, id) {
+  return compileSkillFile(skillsDir, id);
+}
+
+// ../../src/lib/skill-install-core.ts
+function assertInsideWorkspace(root, target) {
+  const normalizedRoot = resolve(root);
+  const normalizedTarget = resolve(target);
+  if (normalizedTarget !== normalizedRoot && !normalizedTarget.startsWith(`${normalizedRoot}/`)) {
+    throw new Error("invalid_path");
+  }
+}
+async function fileExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installSkillToWorkspace(input) {
+  if (!isAgentName(input.agent)) {
+    return { ok: false, error: "unknown_agent" };
+  }
+  const content = await loadSkillFileContent(input.skillsDir, input.skillId);
+  if (!content) {
+    return { ok: false, error: "skill_not_found" };
+  }
+  const root = resolve(input.workspaceRoot);
+  const relativePath = agentSkillPath(input.agent, input.skillId);
+  const absolutePath = resolve(root, relativePath);
+  try {
+    assertInsideWorkspace(root, absolutePath);
+  } catch {
+    return { ok: false, error: "invalid_path" };
+  }
+  if (!input.force && await fileExists(absolutePath)) {
+    return { ok: true, path: relativePath, skipped: true };
+  }
+  await mkdir(dirname2(absolutePath), { recursive: true });
+  await writeFile(absolutePath, content, "utf-8");
+  return { ok: true, path: relativePath, skipped: false };
+}
+async function installStackToWorkspace(input) {
+  const summary = { installed: [], skipped: [], failed: [] };
+  const total = input.skillIds.length;
+  for (const [index, skillId] of input.skillIds.entries()) {
+    const result = await installSkillToWorkspace({
+      skillId,
+      agent: input.agent,
+      workspaceRoot: input.workspaceRoot,
+      skillsDir: input.skillsDir,
+      force: input.force
+    });
+    input.onProgress?.({ index: index + 1, total, skillId, result });
+    if (!result.ok) {
+      summary.failed.push({ skillId, error: result.error });
+      continue;
+    }
+    if (result.skipped) {
+      summary.skipped.push(skillId);
+    } else {
+      summary.installed.push(skillId);
+    }
+  }
+  return summary;
+}
+
+// ../../cli/stack-resolve.ts
+import { readFile as readFile2 } from "node:fs/promises";
+var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
+var MANIFEST_PATH = defaultManifestPath(PACKAGE_ROOT);
+var cached = null;
+async function loadCliManifest() {
+  if (cached) return cached;
+  const raw = await readFile2(MANIFEST_PATH, "utf-8");
+  cached = JSON.parse(raw);
+  return cached;
+}
+function normalizeStackInput(input) {
+  return input.trim().toLowerCase().replace(/\.js$/i, "").replace(/\s+/g, "-").replace(/_/g, "-");
+}
+var ALIASES = {
+  nodejs: "node",
+  node: "node",
+  javascript: "js",
+  js: "js",
+  typescript: "ts",
+  ts: "ts",
+  fastapi: "fastapi",
+  react: "react",
+  angular: "angular",
+  java: "java",
+  spring: "spring-boot",
+  springboot: "spring-boot",
+  "spring-boot": "spring-boot",
+  docker: "docker",
+  kubernetes: "k9",
+  k8s: "k9",
+  k9s: "k9",
+  k9: "k9",
+  postgres: "postgresql",
+  postgresql: "postgresql",
+  mysql: "mysql",
+  prisma: "prisma"
+};
+function resolveStackId(input, manifest) {
+  const normalized = normalizeStackInput(input);
+  const alias = ALIASES[normalized];
+  if (alias && manifest.skillsByStack[alias]) return alias;
+  if (manifest.skillsByStack[normalized]) return normalized;
+  const byLabel = manifest.stacks.find(
+    (stack) => normalizeStackInput(stack.label) === normalized
+  );
+  if (byLabel) return byLabel.id;
+  return null;
+}
+function formatStackList(manifest) {
+  return manifest.stacks.map((stack) => {
+    const count = manifest.skillsByStack[stack.id]?.length ?? 0;
+    return `  ${stack.label.padEnd(14)} (${stack.id}) \u2014 ${count} skills`;
+  }).join("\n");
+}
+
+// ../../cli/main.ts
+var PACKAGE_ROOT2 = resolvePackageRoot(import.meta.url);
+var SKILLS_DIR = defaultSkillsDir(PACKAGE_ROOT2);
+function printHelp() {
+  console.log(`arboris-cli \u2014 installe les skills IA recommand\xE9s pour une techno
+
+Usage:
+  npx arboris-cli <techno> [options]
+  npx arboris-cli list
+
+Exemples:
+  npx arboris-cli node
+  npx arboris-cli node.js --agent cursor
+  npx arboris-cli typescript --force
+
+Technos (alias accept\xE9s: node.js, k8s, spring, postgres\u2026):
+  node, js, ts, fastapi, react, angular, java, spring-boot,
+  docker, k9, postgresql, mysql, prisma
+
+Options:
+  --agent <name>   Agent cible: cursor | claude | codex | copilot (d\xE9faut: cursor)
+  --cwd <path>     Projet cible (d\xE9faut: r\xE9pertoire courant)
+  --force          \xC9crase les skills d\xE9j\xE0 install\xE9s
+  --dry-run        Affiche sans \xE9crire
+  -h, --help       Aide
+`);
+}
+function parseArgs(argv) {
+  const options = {
+    agent: "Cursor",
+    cwd: process.cwd(),
+    dryRun: false,
+    force: false,
+    help: false
+  };
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    if (arg === "--force") {
+      options.force = true;
+      continue;
+    }
+    if (arg === "--agent") {
+      const value = argv[++i];
+      if (!value) throw new Error("Option --agent requiert une valeur.");
+      const normalized = value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+      if (!isAgentName(normalized)) {
+        throw new Error(`Agent inconnu: ${value}. Utilise cursor, claude, codex ou copilot.`);
+      }
+      options.agent = normalized;
+      continue;
+    }
+    if (arg === "--cwd") {
+      const value = argv[++i];
+      if (!value) throw new Error("Option --cwd requiert un chemin.");
+      options.cwd = resolve2(value);
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Option inconnue: ${arg}`);
+    }
+    positional.push(arg);
+  }
+  return { command: positional[0] ?? null, options };
+}
+async function runList() {
+  const manifest = await loadCliManifest();
+  console.log("Technos disponibles:\n");
+  console.log(formatStackList(manifest));
+  console.log("\nExemple: npx arboris-cli node");
+}
+async function runInstall(stackInput, options) {
+  const manifest = await loadCliManifest();
+  const stackId = resolveStackId(stackInput, manifest);
+  if (!stackId) {
+    console.error(`Techno inconnue: "${stackInput}"`);
+    console.error("\nTechnos disponibles:\n");
+    console.error(formatStackList(manifest));
+    process.exit(1);
+  }
+  const stack = manifest.stacks.find((s) => s.id === stackId);
+  const skillIds = manifest.skillsByStack[stackId] ?? [];
+  if (skillIds.length === 0) {
+    console.error(`Aucun skill associ\xE9 \xE0 ${stack?.label ?? stackId}.`);
+    process.exit(1);
+  }
+  console.log(
+    `${options.dryRun ? "[dry-run] " : ""}Installation de ${skillIds.length} skills pour ${stack?.label ?? stackId} \u2192 ${options.agent} (${options.cwd})`
+  );
+  if (options.dryRun) {
+    for (const skillId of skillIds) {
+      console.log(`  \u2022 ${skillId}`);
+    }
+    return;
+  }
+  const summary = await installStackToWorkspace({
+    skillIds,
+    agent: options.agent,
+    workspaceRoot: options.cwd,
+    skillsDir: SKILLS_DIR,
+    force: options.force,
+    onProgress: ({ index, total, skillId, result }) => {
+      if (!result.ok) {
+        process.stdout.write(`  [${index}/${total}] \u2717 ${skillId} (${result.error})
+`);
+        return;
+      }
+      if (result.skipped) {
+        process.stdout.write(`  [${index}/${total}] \u2298 ${skillId} (d\xE9j\xE0 pr\xE9sent)
+`);
+        return;
+      }
+      process.stdout.write(`  [${index}/${total}] \u2713 ${skillId} \u2192 ${result.path}
+`);
+    }
+  });
+  console.log(
+    `
+Termin\xE9: ${summary.installed.length} install\xE9s, ${summary.skipped.length} ignor\xE9s, ${summary.failed.length} \xE9checs.`
+  );
+  if (summary.failed.length > 0) {
+    process.exit(1);
+  }
+}
+async function main() {
+  try {
+    const { command, options } = parseArgs(process.argv.slice(2));
+    if (options.help || !command) {
+      printHelp();
+      process.exit(command ? 0 : 1);
+    }
+    if (command === "list" || command === "ls") {
+      await runList();
+      return;
+    }
+    await runInstall(command, options);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+void main();

package/manifest.json

@@ -0,0 +1,323 @@
+{
+  "version": 1,
+  "generatedAt": "2026-07-02T13:29:05.519Z",
+  "stacks": [
+    {
+      "id": "node",
+      "label": "Node.js"
+    },
+    {
+      "id": "js",
+      "label": "JavaScript"
+    },
+    {
+      "id": "ts",
+      "label": "TypeScript"
+    },
+    {
+      "id": "fastapi",
+      "label": "FastAPI"
+    },
+    {
+      "id": "react",
+      "label": "React"
+    },
+    {
+      "id": "angular",
+      "label": "Angular"
+    },
+    {
+      "id": "java",
+      "label": "Java"
+    },
+    {
+      "id": "spring-boot",
+      "label": "Spring Boot"
+    },
+    {
+      "id": "docker",
+      "label": "Docker"
+    },
+    {
+      "id": "k9",
+      "label": "K9"
+    },
+    {
+      "id": "postgresql",
+      "label": "PostgreSQL"
+    },
+    {
+      "id": "mysql",
+      "label": "MySQL"
+    },
+    {
+      "id": "prisma",
+      "label": "Prisma"
+    }
+  ],
+  "skillsByStack": {
+    "node": [
+      "ai-regression-testing",
+      "autonomous-loops",
+      "backend-patterns",
+      "bun-runtime",
+      "ck",
+      "codebase-onboarding",
+      "configure-ecc",
+      "cost-tracking",
+      "database-migrations",
+      "deployment-patterns",
+      "django-celery",
+      "dmux-workflows",
+      "docker-patterns",
+      "e2e-testing",
+      "ecc-guide",
+      "energy-procurement",
+      "exa-search",
+      "flox-environments",
+      "healthcare-eval-harness",
+      "kubernetes-patterns",
+      "mcp-server-patterns",
+      "mysql-patterns",
+      "nodejs-keccak256",
+      "prisma-patterns",
+      "prompt-optimizer",
+      "react-performance",
+      "react-testing",
+      "redis-patterns",
+      "search-first",
+      "strategic-compact",
+      "tdd-workflow",
+      "ui-demo",
+      "vite-patterns",
+      "windows-desktop-e2e"
+    ],
+    "js": [
+      "bun-runtime",
+      "coding-standards",
+      "configure-ecc",
+      "django-security",
+      "error-handling",
+      "frontend-slides",
+      "hexagonal-architecture",
+      "iterative-retrieval",
+      "laravel-security",
+      "mcp-server-patterns",
+      "mysql-patterns",
+      "nodejs-keccak256",
+      "plankton-code-quality",
+      "quarkus-verification",
+      "react-native-patterns",
+      "react-performance",
+      "ui-demo",
+      "verification-loop",
+      "vite-patterns"
+    ],
+    "ts": [
+      "agent-payment-x402",
+      "agent-sort",
+      "ai-regression-testing",
+      "api-connector-builder",
+      "api-design",
+      "autonomous-loops",
+      "backend-patterns",
+      "benchmark",
+      "bun-runtime",
+      "clickhouse-io",
+      "codebase-onboarding",
+      "coding-standards",
+      "configure-ecc",
+      "database-migrations",
+      "deployment-patterns",
+      "e2e-testing",
+      "error-handling",
+      "evm-token-decimals",
+      "frontend-patterns",
+      "healthcare-cdss-patterns",
+      "healthcare-emr-patterns",
+      "healthcare-phi-compliance",
+      "hexagonal-architecture",
+      "laravel-plugin-discovery",
+      "mailtrap-email-integration",
+      "mcp-server-patterns",
+      "nestjs-patterns",
+      "nodejs-keccak256",
+      "orch-pipeline",
+      "plan-orchestrate",
+      "plankton-code-quality",
+      "prisma-patterns",
+      "prompt-optimizer",
+      "react-native-patterns",
+      "recsys-pipeline-architect",
+      "security-review",
+      "tdd-workflow",
+      "verification-loop",
+      "vite-patterns",
+      "vue-patterns"
+    ],
+    "fastapi": [
+      "codebase-onboarding",
+      "error-handling",
+      "fastapi-patterns",
+      "flox-environments",
+      "gan-style-harness",
+      "ml-adoption-playbook",
+      "python-patterns",
+      "python-testing",
+      "recsys-pipeline-architect"
+    ],
+    "react": [
+      "agent-harness-construction",
+      "agent-sort",
+      "angular-developer",
+      "benchmark-methodology",
+      "click-path-audit",
+      "codebase-onboarding",
+      "coding-standards",
+      "configure-ecc",
+      "continuous-learning-v2",
+      "documentation-lookup",
+      "error-handling",
+      "frontend-a11y",
+      "frontend-patterns",
+      "gan-style-harness",
+      "liquid-glass-design",
+      "motion-advanced",
+      "motion-foundations",
+      "motion-patterns",
+      "motion-ui",
+      "prompt-optimizer",
+      "react-native-patterns",
+      "react-patterns",
+      "react-performance",
+      "react-testing",
+      "remotion-video-creation",
+      "security-review",
+      "taste",
+      "tdd-workflow",
+      "video-editing",
+      "vite-patterns"
+    ],
+    "angular": [
+      "angular-developer",
+      "codebase-onboarding",
+      "react-patterns"
+    ],
+    "java": [
+      "agent-payment-x402",
+      "configure-ecc",
+      "hexagonal-architecture",
+      "inherit-legacy-style",
+      "java-coding-standards",
+      "jpa-patterns",
+      "kotlin-patterns",
+      "kotlin-testing",
+      "plan-orchestrate",
+      "prompt-optimizer",
+      "quarkus-patterns",
+      "quarkus-security",
+      "quarkus-tdd",
+      "quarkus-verification",
+      "repo-scan",
+      "springboot-patterns",
+      "springboot-security",
+      "springboot-tdd",
+      "springboot-verification",
+      "tinystruct-patterns"
+    ],
+    "spring-boot": [
+      "agent-payment-x402",
+      "configure-ecc",
+      "java-coding-standards",
+      "jpa-patterns",
+      "prompt-optimizer",
+      "springboot-patterns",
+      "springboot-security",
+      "springboot-tdd",
+      "springboot-verification"
+    ],
+    "docker": [
+      "agent-eval",
+      "benchmark",
+      "codebase-onboarding",
+      "deployment-patterns",
+      "docker-patterns",
+      "flox-environments",
+      "homelab-pihole-dns",
+      "homelab-wireguard-vpn",
+      "kubernetes-patterns",
+      "mle-workflow",
+      "production-audit",
+      "prompt-optimizer",
+      "quarkus-verification",
+      "safety-guard",
+      "uncloud",
+      "vite-patterns"
+    ],
+    "k9": [
+      "deployment-patterns",
+      "docker-patterns",
+      "flox-environments",
+      "kubernetes-patterns",
+      "prompt-optimizer",
+      "quarkus-security",
+      "uncloud"
+    ],
+    "postgresql": [
+      "agentic-os",
+      "architecture-decision-records",
+      "blueprint",
+      "clickhouse-io",
+      "codebase-onboarding",
+      "configure-ecc",
+      "csharp-testing",
+      "database-migrations",
+      "deployment-patterns",
+      "django-patterns",
+      "django-security",
+      "django-verification",
+      "docker-patterns",
+      "flox-environments",
+      "git-workflow",
+      "golang-patterns",
+      "golang-testing",
+      "hexagonal-architecture",
+      "jpa-patterns",
+      "knowledge-ops",
+      "kotlin-exposed-patterns",
+      "kotlin-ktor-patterns",
+      "kotlin-patterns",
+      "mle-workflow",
+      "mysql-patterns",
+      "perl-testing",
+      "plan-orchestrate",
+      "postgres-patterns",
+      "prisma-patterns",
+      "prompt-optimizer",
+      "python-testing",
+      "quarkus-patterns",
+      "quarkus-verification",
+      "redis-patterns",
+      "springboot-tdd",
+      "springboot-verification",
+      "uncloud"
+    ],
+    "mysql": [
+      "clickhouse-io",
+      "database-migrations",
+      "laravel-security",
+      "mysql-patterns",
+      "python-testing"
+    ],
+    "prisma": [
+      "ai-regression-testing",
+      "architecture-decision-records",
+      "codebase-onboarding",
+      "database-migrations",
+      "deployment-patterns",
+      "documentation-lookup",
+      "nestjs-patterns",
+      "prisma-patterns"
+    ]
+  }
+}