@rubix0270/arboris 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,376 @@
+#!/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 resolvePackageRoot(fromModuleUrl) {
+  let dir = dirname(fileURLToPath(fromModuleUrl));
+  for (let i = 0; i < 8; i++) {
+    if (existsSync(join(dir, "package.json")) && existsSync(join(dir, "prisma", "skills"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return dirname(fileURLToPath(fromModuleUrl));
+}
+function defaultSkillsDir(packageRoot) {
+  return join(packageRoot, "prisma", "skills");
+}
+
+// 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";
+import { join as join3 } from "node:path";
+var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
+var MANIFEST_PATH = join3(PACKAGE_ROOT, "cli", "manifest.json");
+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 @rubix0270/arboris <techno> [options]
+  npx @rubix0270/arboris list
+
+Exemples:
+  npx @rubix0270/arboris node
+  npx @rubix0270/arboris node.js --agent cursor
+  npx @rubix0270/arboris 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 @rubix0270/arboris 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/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@rubix0270/arboris",
+  "version": "1.0.0",
+  "description": "Catalogue de skills IA — installe les skills recommandés pour ta stack via CLI.",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "arboris": "dist/cli.mjs"
+  },
+  "files": [
+    "dist/cli.mjs",
+    "cli/manifest.json",
+    "prisma/skills"
+  ],
+  "imports": {
+    "#/*": "./src/*"
+  },
+  "scripts": {
+    "dev": "vite dev --port 3000",
+    "build": "vite build",
+    "start": "node .output/server/index.mjs",
+    "preview": "vite preview",
+    "generate-routes": "tsr generate",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "cli:manifest": "tsx scripts/generate-cli-manifest.ts",
+    "build:cli": "npm run cli:manifest && node scripts/build-cli.mjs",
+    "prepack": "npm run build:cli",
+    "db:generate": "prisma generate",
+    "db:up": "docker compose up -d",
+    "db:down": "docker compose down",
+    "db:setup": "docker compose up -d && prisma migrate deploy && prisma db seed",
+    "db:push": "prisma db push",
+    "db:migrate": "prisma migrate dev",
+    "db:seed": "prisma db seed",
+    "db:studio": "prisma studio",
+    "db:reset": "prisma migrate reset --force"
+  },
+  "prisma": {
+    "seed": "tsx prisma/seed.ts"
+  },
+  "dependencies": {
+    "@prisma/client": "^6.19.2",
+    "@tailwindcss/vite": "^4.1.18",
+    "@tanstack/react-devtools": "latest",
+    "@tanstack/react-router": "latest",
+    "@tanstack/react-router-devtools": "latest",
+    "@tanstack/react-router-ssr-query": "latest",
+    "@tanstack/react-start": "latest",
+    "@tanstack/router-plugin": "^1.132.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "tailwindcss": "^4.1.18"
+  },
+  "devDependencies": {
+    "@tanstack/devtools-vite": "latest",
+    "@tanstack/router-cli": "^1.132.0",
+    "@types/node": "^22.10.2",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@vitejs/plugin-react": "^6.0.1",
+    "esbuild": "^0.25.12",
+    "prisma": "^6.19.2",
+    "tsx": "^4.19.2",
+    "typescript": "^6.0.2",
+    "vite": "^8.0.0",
+    "vitest": "^4.1.5"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "lightningcss",
+      "@prisma/client",
+      "@prisma/engines",
+      "prisma"
+    ]
+  }
+}

package/prisma/skills/accessibility/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: accessibility
+description: Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA
+  standards. Use this skill to generate semantic ARIA for Web and accessibility traits for Web and Native platforms (iOS/Android).
+metadata:
+  origin: ECC
+---
+
+# Accessibility (WCAG 2.2)
+
+This skill ensures that digital interfaces are Perceivable, Operable, Understandable, and Robust (POUR) for all users, including those using screen readers, switch controls, or keyboard navigation. It focuses on the technical implementation of WCAG 2.2 success criteria.
+
+## When to Use
+
+- Defining UI component specifications for Web, iOS, or Android.
+- Auditing existing code for accessibility barriers or compliance gaps.
+- Implementing new WCAG 2.2 standards like Target Size (Minimum) and Focus Appearance.
+- Mapping high-level design requirements to technical attributes (ARIA roles, traits, hints).
+
+## Core Concepts
+
+- **POUR Principles**: The foundation of WCAG (Perceivable, Operable, Understandable, Robust).
+- **Semantic Mapping**: Using native elements over generic containers to provide built-in accessibility.
+- **Accessibility Tree**: The representation of the UI that assistive technologies actually "read."
+- **Focus Management**: Controlling the order and visibility of the keyboard/screen reader cursor.
+- **Labeling & Hints**: Providing context through `aria-label`, `accessibilityLabel`, and `contentDescription`.
+
+## How It Works
+
+### Step 1: Identify the Component Role
+
+Determine the functional purpose (e.g., Is this a button, a link, or a tab?). Use the most semantic native element available before resorting to custom roles.
+
+### Step 2: Define Perceivable Attributes
+
+- Ensure text contrast meets **4.5:1** (normal) or **3:1** (large/UI).
+- Add text alternatives for non-text content (images, icons).
+- Implement responsive reflow (up to 400% zoom without loss of function).
+
+### Step 3: Implement Operable Controls
+
+- Ensure a minimum **24x24 CSS pixel** target size (WCAG 2.2 SC 2.5.8).
+- Verify all interactive elements are reachable via keyboard and have a visible focus indicator (SC 2.4.11).
+- Provide single-pointer alternatives for dragging movements.
+
+### Step 4: Ensure Understandable Logic
+
+- Use consistent navigation patterns.
+- Provide descriptive error messages and suggestions for correction (SC 3.3.3).
+- Implement "Redundant Entry" (SC 3.3.7) to prevent asking for the same data twice.
+
+### Step 5: Verify Robust Compatibility
+
+- Use correct `Name, Role, Value` patterns.
+- Implement `aria-live` or live regions for dynamic status updates.
+
+## Accessibility Architecture Diagram
+
+```mermaid
+flowchart TD
+  UI["UI Component"] --> Platform{Platform?}
+  Platform -->|Web| ARIA["WAI-ARIA + HTML5"]
+  Platform -->|iOS| SwiftUI["Accessibility Traits + Labels"]
+  Platform -->|Android| Compose["Semantics + ContentDesc"]
+
+  ARIA --> AT["Assistive Technology (Screen Readers, Switches)"]
+  SwiftUI --> AT
+  Compose --> AT
+```
+
+## Cross-Platform Mapping
+
+| Feature            | Web (HTML/ARIA)          | iOS (SwiftUI)                        | Android (Compose)                                           |
+| :----------------- | :----------------------- | :----------------------------------- | :---------------------------------------------------------- |
+| **Primary Label**  | `aria-label` / `<label>` | `.accessibilityLabel()`              | `contentDescription`                                        |
+| **Secondary Hint** | `aria-describedby`       | `.accessibilityHint()`               | `Modifier.semantics { stateDescription = ... }`             |
+| **Action Role**    | `role="button"`          | `.accessibilityAddTraits(.isButton)` | `Modifier.semantics { role = Role.Button }`                 |
+| **Live Updates**   | `aria-live="polite"`     | `.accessibilityLiveRegion(.polite)`  | `Modifier.semantics { liveRegion = LiveRegionMode.Polite }` |
+
+## Examples
+
+### Web: Accessible Search
+
+```html
+<form role="search">
+  <label for="search-input" class="sr-only">Search products</label>
+  <input type="search" id="search-input" placeholder="Search..." />
+  <button type="submit" aria-label="Submit Search">
+    <svg aria-hidden="true">...</svg>
+  </button>
+</form>
+```
+
+### iOS: Accessible Action Button
+
+```swift
+Button(action: deleteItem) {
+    Image(systemName: "trash")
+}
+.accessibilityLabel("Delete item")
+.accessibilityHint("Permanently removes this item from your list")
+.accessibilityAddTraits(.isButton)
+```
+
+### Android: Accessible Toggle
+
+```kotlin
+Switch(
+    checked = isEnabled,
+    onCheckedChange = { onToggle() },
+    modifier = Modifier.semantics {
+        contentDescription = "Enable notifications"
+    }
+)
+```
+
+## Anti-Patterns to Avoid
+
+- **Div-Buttons**: Using a `<div>` or `<span>` for a click event without adding a role and keyboard support.
+- **Color-Only Meaning**: Indicating an error or status _only_ with a color change (e.g., turning a border red).
+- **Uncontained Modal Focus**: Modals that don't trap focus, allowing keyboard users to navigate background content while the modal is open. Focus must be contained _and_ escapable via the `Escape` key or an explicit close button (WCAG SC 2.1.2).
+- **Redundant Alt Text**: Using "Image of..." or "Picture of..." in alt text (screen readers already announce the role "Image").
+
+## Best Practices Checklist
+
+- [ ] Interactive elements meet the **24x24px** (Web) or **44x44pt** (Native) target size.
+- [ ] Focus indicators are clearly visible and high-contrast.
+- [ ] Modals **contain focus** while open, and release it cleanly on close (`Escape` key or close button).
+- [ ] Dropdowns and menus restore focus to the trigger element on close.
+- [ ] Forms provide text-based error suggestions.
+- [ ] All icon-only buttons have a descriptive text label.
+- [ ] Content reflows properly when text is scaled.
+
+## References
+
+- [WCAG 2.2 Guidelines](https://www.w3.org/TR/WCAG22/)
+- [WAI-ARIA Authoring Practices](https://www.w3.org/TR/wai-aria-practices/)
+- [iOS Accessibility Programming Guide](https://developer.apple.com/documentation/accessibility)
+- [iOS Human Interface Guidelines - Accessibility](https://developer.apple.com/design/human-interface-guidelines/accessibility)
+- [Android Accessibility Developer Guide](https://developer.android.com/guide/topics/ui/accessibility)
+
+## Related Skills
+
+- `frontend-patterns`
+- `design-system`
+- `liquid-glass-design`
+- `swiftui-patterns`