@rubix0270/arboris 1.0.2 → 1.0.4

package/package.json

@@ -1,37 +1,25 @@
-{
-  "name": "@rubix0270/arboris",
-  "version": "1.0.2",
-  "description": "Installe les skills IA recommandés pour ta stack (Node, React, TypeScript…).",
-  "type": "module",
-  "bin": {
-    "arboris": "dist/cli.mjs",
-    "arb": "dist/cli.mjs"
-  },
-  "files": [
-    "dist/cli.mjs",
-    "manifest.json",
-    "prisma/skills"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "prepack": "node ../../scripts/build-cli.mjs"
-  },
-  "keywords": [
-    "skills",
-    "cursor",
-    "claude",
-    "ai",
-    "cli"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ThePheniX974/arboris.git",
-    "directory": "packages/arboris-cli"
-  },
-  "license": "MIT"
-}
+{
+  "name": "@rubix0270/arboris",
+  "version": "1.0.4",
+  "description": "Alias de compatibilité vers arboris-cli.",
+  "type": "module",
+  "bin": {
+    "arboris": "run.mjs",
+    "arboris-cli": "run.mjs"
+  },
+  "dependencies": {
+    "arboris-cli": "^1.1.1"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ThePheniX974/arboris.git",
+    "directory": "packages/rubix-alias"
+  },
+  "license": "MIT"
+}

package/run.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+
+const require = createRequire(import.meta.url)
+const root = dirname(require.resolve('arboris-cli/package.json'))
+const cli = join(root, 'dist', 'cli.mjs')
+const child = spawnSync(process.execPath, [cli, ...process.argv.slice(2)], { stdio: 'inherit' })
+process.exit(child.status ?? 1)

package/dist/cli.mjs

@@ -1,383 +0,0 @@
-#!/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 \u2014 installe les skills IA recommand\xE9s pour une techno
-
-Usage:
-  npx arb <techno> [options]
-  npx arboris-cli <techno> [options]
-  npx @rubix0270/arboris <techno> [options]
-
-Exemples:
-  npx arb node
-  npx arboris-cli node.js --agent cursor
-  npx arb 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 arb 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();