fullstack-skills 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fullstack-skills contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,199 @@
+<div align="center">
+
+# ⚡ fullstack-skills
+
+**Universal AI developer skills for modern Full-Stack Web Development.**  
+Install 20 battle-tested engineering & UI/UX skills into your favorite AI coding environment in seconds.
+
+[![npm version](https://img.shields.io/npm/v/fullstack-skills.svg?style=flat-square&color=00d26a)](https://www.npmjs.com/package/fullstack-skills)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](LICENSE)
+[![Zero Dependencies](https://img.shields.io/badge/dependencies-0-success.svg?style=flat-square)](package.json)
+[![Package Size](https://img.shields.io/badge/package%20size-48%20KB-blueviolet.svg?style=flat-square)](https://www.npmjs.com/package/fullstack-skills)
+
+</div>
+
+---
+
+## ⚡ 10-Second Quick Start
+
+You don't even need to install anything permanently. Just run:
+
+```bash
+npx fullstack-skills
+```
+
+An interactive menu will guide you through picking your environment and skill bundle:
+
+```text
+================================================================
+  ⚡ fullstack-skills v1.0.0
+  Universal AI Skills for Claude Code, Antigravity, OpenCode & VS Code
+================================================================
+
+[1/3] Installation Scope:
+  ❯ Current Project (./)      (Recommended: installs inside this repository)
+    Global Machine (~/)       (Available in any project on your computer)
+
+[2/3] Target AI Environment:
+  ❯ Claude Code CLI           (~/.claude/skills/ or .claude/skills/)
+    Google Antigravity        (~/.gemini/config/skills/ or .agents/skills/)
+    OpenCode                  (~/.config/opencode/skills/ or .opencode/skills/)
+    VS Code                   (.vscode/skills/ + Copilot / Cline / Roo)
+    All Environments          (Set up all 4 simultaneously)
+
+[3/3] Skill Bundle:
+  ❯ Full Stack                (All 20 Frontend & Backend Skills)
+    Frontend UI/UX Only       (11 Design, A11y, Layout & Motion Skills)
+    Backend Only              (9 Architecture, API, Auth & DB Skills)
+
+✔ Done! Installed 20 skills to ./.claude/skills/
+```
+
+---
+
+## 📦 Installation Options
+
+Choose the method that fits your workflow:
+
+### Option A: Direct Execution (No Install)
+```bash
+npx fullstack-skills
+```
+
+### Option B: Install Globally (Run from any folder)
+```bash
+npm install -g fullstack-skills
+
+# Run anywhere:
+fullstack-skills
+```
+
+### Option C: Add to Current Project
+```bash
+npm install fullstack-skills
+
+# Run the installer:
+npx fullstack-skills
+```
+
+---
+
+## 🎯 Supported Environments
+
+| Environment | Global Location | Project Location | AI Extension / Agent Support |
+| :--- | :--- | :--- | :--- |
+| **Claude Code CLI** | `~/.claude/skills/` | `./.claude/skills/` | Native Claude Code skills |
+| **VS Code** | `~/.vscode/skills/` | `./.vscode/skills/` | GitHub Copilot, Roo Code, Cline |
+| **Google Antigravity** | `~/.gemini/config/skills/` | `./.agents/skills/` | Native Antigravity / Gemini agent skills |
+| **OpenCode** | `~/.config/opencode/skills/` | `./.opencode/skills/` | OpenCode agent skill system |
+
+> **VS Code Note**: When installed to a project, `fullstack-skills` automatically configures `.github/copilot-instructions.md` with an index referencing all installed skills so **GitHub Copilot**, **Cline**, and **Roo Code** instantly discover and enforce the skills!
+
+---
+
+## 🤖 How the Skills Work in Your AI Assistant
+
+Once installed, your AI assistant will automatically use the skills as specialist playbooks:
+
+1. **Backend Routing (`use-backend`)**:
+   - When you say *"Build an auth API in FastAPI"* or *"Create an Express user router"*, the AI automatically detects your framework and follows `use-backend` &rarr; `backend-architecture` &rarr; `security` &rarr; `api-design` &rarr; `backend-qa`.
+2. **Frontend Routing (`using-frontend`)**:
+   - When you say *"Design a landing page with hero and pricing"*, the AI routes to `frontend-ui-ux` &rarr; `layout-composition` &rarr; `typography` &rarr; `motion-interaction` &rarr; `accessibility`.
+
+---
+
+## 🚀 Scriptable CLI Flags (CI / Power Users)
+
+Bypass interactive prompts with command-line flags:
+
+```bash
+# Install all 20 skills to Claude Code globally:
+fullstack-skills install -e claude-code -s global -b fullstack -y
+
+# Install frontend only to current VS Code workspace:
+fullstack-skills install -e vscode -s project -b frontend -y
+
+# Install all skills across all 4 environments:
+npx fullstack-skills install -e all -s project -y
+
+# Force overwrite existing skill files:
+fullstack-skills install -e claude-code -f
+
+# List all available skills:
+fullstack-skills list
+```
+
+### Flags Reference
+
+| Flag | Shorthand | Options | Description |
+| :--- | :--- | :--- | :--- |
+| `--editor` | `-e` | `claude-code`, `antigravity`, `opencode`, `vscode`, `all` | Target environment |
+| `--scope` | `-s` | `project`, `global` | Target directory level |
+| `--bundle` | `-b` | `fullstack`, `frontend`, `backend` | Which skill set to install |
+| `--yes` | `-y` | _boolean_ | Skip confirmation prompt |
+| `--force` | `-f` | _boolean_ | Overwrite existing files |
+| `--list` | | _boolean_ | Print all 20 skills & descriptions |
+| `--help` | `-h` | _boolean_ | Show help and usage examples |
+| `--version` | `-v` | _boolean_ | Print installed version |
+
+---
+
+## 📚 Complete Skills Catalog (20 Skills)
+
+### 🎨 Frontend & UI/UX Design (11 Skills)
+| Skill | Description |
+| :--- | :--- |
+| **`using-frontend`** | Master entry point and router for all frontend, component, and UI/UX tasks. |
+| **`frontend-ui-ux`** | Design-first direction: visual hierarchy, whitespace rhythm, color harmony, and micro-interactions. |
+| **`typography`** | Modular type scales, font pairing, line-height, and responsive typography rules. |
+| **`layout-composition`** | Spatial grids, dynamic section rhythm, and modern container layouts. |
+| **`responsive-design`** | Fluid breakpoints, responsive navigation, touch targets, and mobile-first adaptation. |
+| **`shadcn-design-system`** | Radix primitives, Tailwind CSS tokens, and clean variant architectures. |
+| **`motion-interaction`** | Micro-animations, scroll-driven interactions, and smooth CSS transitions. |
+| **`accessibility`** | WCAG 2.1 AA compliance, keyboard navigation, focus rings, and screen reader semantics. |
+| **`design-inspiration`** | Visual benchmark analysis from top modern SaaS, editorial, and ecommerce designs. |
+| **`visual-qa`** | Layout overflow detection, contrast validation, and visual polish audits. |
+| **`bangla-typography`** | Native Bengali/Bangla typography rules, font selections, and line-height calibration. |
+
+### ⚙️ Backend & API Engineering (9 Skills)
+| Skill | Description |
+| :--- | :--- |
+| **`use-backend`** | Master router: detects framework (Express, FastAPI, Django, Next.js, Go, Spring) and routes tasks. |
+| **`backend-architecture`** | Clean layering (Controller &rarr; Service &rarr; Repository), dependency injection, and modular structure. |
+| **`api-design`** | RESTful API design, request/response models, pagination, JSON envelopes, and status codes. |
+| **`security`** | Authentication (JWT/OAuth), authorization (RBAC/ABAC), injection prevention, CORS, and OWASP hardening. |
+| **`data-persistence`** | Database schemas, ORM queries, migrations, atomic transactions, and N+1 query elimination. |
+| **`performance-scalability`** | Redis caching, async task queues, non-blocking I/O, and latency profiling. |
+| **`rate-limiting-resilience`** | Exponential backoff, jitter, circuit breakers, timeouts, and DDoS protections. |
+| **`observability`** | Structured JSON logging, correlation IDs, health checks (`/health/live`, `/health/ready`), and metrics. |
+| **`backend-qa`** | Pre-ship verification checklists, contract tests, and test runner execution. |
+
+---
+
+## 🗜️ Ultra-Lightweight & Gzip-Compressed
+
+- **Zero dependencies**: No heavy node_modules to download.
+- **Fast execution**: Tarball is only **~48 KB** compressed.
+- Run `npm run compact` to inspect native `node:zlib` high-density archive generation.
+
+---
+
+## 🤝 Contributing & Local Development
+
+```bash
+# Clone the repository
+git clone https://github.com/MU1147-LEGEND/fullstack-skills.git
+cd fullstack-skills
+
+# Run tests (100% pass)
+npm test
+
+# Try the CLI locally
+node bin/cli.js
+```
+
+---
+
+## 📄 License
+
+MIT &copy; 2026 [MU1147-LEGEND](https://github.com/MU1147-LEGEND)

package/bin/cli.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import { parseArgs } from '../src/flags.js';
+import { ui, c } from '../src/ui.js';
+import { installSkills, listSkills, getAdapters } from '../src/installer.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+async function getVersion() {
+  try {
+    const pkgJson = await fs.readFile(path.join(PACKAGE_ROOT, 'package.json'), 'utf8');
+    return JSON.parse(pkgJson).version || '1.0.0';
+  } catch {
+    return '1.0.0';
+  }
+}
+
+function printHelp(version) {
+  ui.banner();
+  console.log(`${c.bold}USAGE:${c.reset}`);
+  console.log(`  ${c.cyan}npx fullstack-skills${c.reset}                    Launch interactive installer wizard`);
+  console.log(`  ${c.cyan}fullstack-skills install [options]${c.reset}      Install skills with flags`);
+  console.log(`  ${c.cyan}fullstack-skills list${c.reset}                   List all 20 skills & descriptions`);
+  console.log(`  ${c.cyan}fullstack-skills --help${c.reset}                 Show this help message`);
+  console.log(`  ${c.cyan}fullstack-skills --version${c.reset}              Show version number\n`);
+
+  console.log(`${c.bold}OPTIONS:${c.reset}`);
+  console.log(`  ${c.cyan}-e, --editor <id>${c.reset}        Target environment:`);
+  console.log(`                            ${c.dim}claude-code | antigravity | opencode | vscode | all${c.reset}`);
+  console.log(`  ${c.cyan}-s, --scope <type>${c.reset}       Installation scope:`);
+  console.log(`                            ${c.dim}project (./) | global (~/)${c.reset}`);
+  console.log(`  ${c.cyan}-b, --bundle <bundle>${c.reset}    Skill bundle:`);
+  console.log(`                            ${c.dim}fullstack (20) | frontend (11) | backend (9)${c.reset}`);
+  console.log(`  ${c.cyan}-y, --yes${c.reset}                Skip confirmation prompts`);
+  console.log(`  ${c.cyan}-f, --force${c.reset}              Overwrite existing skill files`);
+  console.log(`  ${c.cyan}-h, --help${c.reset}               Show help`);
+  console.log(`  ${c.cyan}-v, --version${c.reset}            Show version\n`);
+
+  console.log(`${c.bold}EXAMPLES:${c.reset}`);
+  console.log(`  ${c.dim}# Interactive prompt:${c.reset}`);
+  console.log(`  npx fullstack-skills\n`);
+  console.log(`  ${c.dim}# Install full-stack to Claude Code globally:${c.reset}`);
+  console.log(`  fullstack-skills install --editor claude-code --scope global --bundle fullstack\n`);
+  console.log(`  ${c.dim}# Install frontend only to current VS Code project:${c.reset}`);
+  console.log(`  fullstack-skills install --editor vscode --scope project --bundle frontend -y\n`);
+  console.log(`  ${c.dim}# Install to all environments:${c.reset}`);
+  console.log(`  npx fullstack-skills install --editor all --scope project --yes\n`);
+}
+
+async function handleList() {
+  ui.banner();
+  const skills = await listSkills();
+
+  console.log(`${c.bold}${c.cyan}FRONTEND & UI/UX SKILLS (11):${c.reset}`);
+  const frontend = skills.filter((s) => s.category === 'frontend');
+  for (const s of frontend) {
+    console.log(`  ${c.green}✔ ${c.bold}${s.name.padEnd(24)}${c.reset} ${c.dim}${s.description}${c.reset}`);
+  }
+
+  console.log(`\n${c.bold}${c.cyan}BACKEND & API ENGINEERING SKILLS (9):${c.reset}`);
+  const backend = skills.filter((s) => s.category === 'backend');
+  for (const s of backend) {
+    console.log(`  ${c.green}✔ ${c.bold}${s.name.padEnd(24)}${c.reset} ${c.dim}${s.description}${c.reset}`);
+  }
+  console.log(`\nTotal: ${c.bold}20 skills${c.reset} ready to install.\n`);
+}
+
+async function main() {
+  process.on('SIGINT', () => {
+    console.log(`\n${c.yellow}Operation cancelled by user.${c.reset}`);
+    process.exit(130);
+  });
+
+  const version = await getVersion();
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    ui.error(err.message);
+    console.log(`Run ${c.cyan}fullstack-skills --help${c.reset} for usage details.`);
+    process.exit(1);
+  }
+
+  if (args.help) {
+    printHelp(version);
+    return;
+  }
+
+  if (args.version) {
+    console.log(`fullstack-skills v${version}`);
+    return;
+  }
+
+  if (args.list) {
+    await handleList();
+    return;
+  }
+
+  ui.banner();
+
+  let { editor, scope, bundle, yes, force } = args;
+
+  // Interactive Flow if options are missing
+  if (!editor || !scope || !bundle) {
+    // 1. Detect Scope
+    if (!scope) {
+      let isProject = false;
+      try {
+        await fs.access(path.join(process.cwd(), 'package.json'));
+        isProject = true;
+      } catch {
+        try {
+          await fs.access(path.join(process.cwd(), '.git'));
+          isProject = true;
+        } catch {
+          // not in project root
+        }
+      }
+
+      ui.step(1, 3, 'Installation Scope');
+      scope = await ui.select('Where would you like to install the skills?', [
+        {
+          label: 'Current Project',
+          value: 'project',
+          desc: isProject ? 'Recommended: Detected local repository' : 'Local folder (.claude / .agents / .vscode)'
+        },
+        {
+          label: 'Global Machine',
+          value: 'global',
+          desc: 'Available everywhere on this machine'
+        }
+      ], isProject ? 0 : 1);
+    }
+
+    // 2. Select Target Environment
+    if (!editor) {
+      ui.step(2, 3, 'Target AI Environment');
+      editor = await ui.select('Select the environment you want to configure:', [
+        { label: 'Claude Code CLI', value: 'claude-code', desc: '~/.claude/skills/ or .claude/skills/' },
+        { label: 'Google Antigravity', value: 'antigravity', desc: '~/.gemini/config/skills/ or .agents/skills/' },
+        { label: 'OpenCode', value: 'opencode', desc: '~/.config/opencode/skills/ or .opencode/skills/' },
+        { label: 'VS Code', value: 'vscode', desc: '.vscode/skills/ with Copilot / Cline / Roo support' },
+        { label: 'All Environments', value: 'all', desc: 'Install and configure all 4 environments simultaneously' }
+      ]);
+    }
+
+    // 3. Select Skill Bundle
+    if (!bundle) {
+      ui.step(3, 3, 'Skill Bundle');
+      bundle = await ui.select('Select which skills you want to install:', [
+        { label: 'Full Stack', value: 'fullstack', desc: 'Complete suite: All 20 Frontend & Backend Skills' },
+        { label: 'Frontend UI/UX Only', value: 'frontend', desc: '11 design, accessibility, and UI skills' },
+        { label: 'Backend Engineering Only', value: 'backend', desc: '9 architecture, API, security, and persistence skills' }
+      ]);
+    }
+
+    // Confirmation if not -y
+    if (!yes) {
+      console.log(`\n${c.bold}Configuration Summary:${c.reset}`);
+      console.log(`  • Environment: ${c.cyan}${editor}${c.reset}`);
+      console.log(`  • Scope:       ${c.cyan}${scope}${c.reset}`);
+      console.log(`  • Bundle:      ${c.cyan}${bundle}${c.reset}`);
+
+      const proceed = await ui.confirm('\nProceed with installation?', true);
+      if (!proceed) {
+        console.log(`${c.yellow}Installation cancelled.${c.reset}`);
+        return;
+      }
+    }
+  }
+
+  console.log(`\n${c.cyan}Installing skills...${c.reset}\n`);
+
+  try {
+    const summary = await installSkills({
+      editor,
+      scope,
+      bundle,
+      force
+    });
+
+    for (const res of summary.results) {
+      console.log(`${c.green}${c.bold}✔ ${res.adapterName}${c.reset}`);
+      console.log(`  ${c.dim}Path:${c.reset}  ${res.destination}`);
+      console.log(`  ${c.dim}Count:${c.reset} ${c.bold}${res.installedCount}${c.reset} skills installed`);
+      if (res.postNotes) {
+        console.log(`  ${c.cyan}Tip:${c.reset}   ${res.postNotes}`);
+      }
+      console.log('');
+    }
+
+    console.log(`${c.green}${c.bold}🎉 Done! Successfully installed ${summary.selectedSkillsCount} skills.${c.reset}\n`);
+  } catch (err) {
+    ui.error(err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "fullstack-skills",
+  "version": "1.0.0",
+  "description": "Universal CLI installer for 20 premium Frontend & Backend AI skills across Claude Code, Antigravity, OpenCode, and VS Code",
+  "type": "module",
+  "main": "./src/index.js",
+  "bin": {
+    "fullstack-skills": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "skills.bundle.json.gz",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "skills",
+    "claude-code",
+    "antigravity",
+    "opencode",
+    "vscode",
+    "copilot",
+    "fullstack",
+    "frontend",
+    "backend"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "start": "node bin/cli.js",
+    "compact": "node scripts/compact.js",
+    "prepack": "node scripts/compact.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MU1147-LEGEND/fullstack-skills.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MU1147-LEGEND/fullstack-skills/issues"
+  },
+  "homepage": "https://github.com/MU1147-LEGEND/fullstack-skills#readme",
+  "author": "MU1147-LEGEND",
+  "license": "MIT"
+}

package/src/adapters/antigravity.js

@@ -0,0 +1,27 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { BaseAdapter } from './base.js';
+
+export class AntigravityAdapter extends BaseAdapter {
+  constructor() {
+    super(
+      'antigravity',
+      'Google Antigravity',
+      'Installs skills to ~/.gemini/config/skills/ or .agents/skills/'
+    );
+  }
+
+  resolveDestination({ scope, projectDir, homedir }) {
+    if (scope === 'global') {
+      return path.join(homedir, '.gemini', 'config', 'skills');
+    }
+    return path.join(projectDir, '.agents', 'skills');
+  }
+
+  async postInstall({ scope, destDir }) {
+    if (scope === 'global') {
+      return `Antigravity will load these skills globally from ~/.gemini/config/skills/`;
+    }
+    return `Antigravity will load these skills in this workspace from .agents/skills/`;
+  }
+}

package/src/adapters/base.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+export class BaseAdapter {
+  constructor(id, name, description) {
+    this.id = id;
+    this.name = name;
+    this.description = description;
+  }
+
+  resolveDestination({ scope, projectDir = process.cwd(), homedir = os.homedir() }) {
+    throw new Error('resolveDestination must be implemented by adapter');
+  }
+
+  async ensureDir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+
+  async copyDir(src, dest, force = false) {
+    await this.ensureDir(dest);
+    const entries = await fs.readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        await this.copyDir(srcPath, destPath, force);
+      } else {
+        if (!force) {
+          try {
+            await fs.access(destPath);
+            // File exists, skip if not force
+            continue;
+          } catch {
+            // File does not exist, proceed
+          }
+        }
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  }
+
+  async install({ skills, scope, projectDir = process.cwd(), homedir = os.homedir(), force = false }) {
+    const destDir = this.resolveDestination({ scope, projectDir, homedir });
+    await this.ensureDir(destDir);
+
+    const installedSkills = [];
+
+    for (const skill of skills) {
+      const targetSkillDir = path.join(destDir, skill.name);
+      await this.ensureDir(targetSkillDir);
+
+      if (skill.files) {
+        for (const [filename, fileContent] of Object.entries(skill.files)) {
+          const targetFilePath = path.join(targetSkillDir, filename);
+          if (!force) {
+            try {
+              await fs.access(targetFilePath);
+              continue;
+            } catch {
+              // proceed
+            }
+          }
+          await fs.writeFile(targetFilePath, fileContent, 'utf8');
+        }
+      } else if (skill.path) {
+        await this.copyDir(skill.path, targetSkillDir, force);
+      }
+
+      installedSkills.push(skill.name);
+    }
+
+    const postNotes = await this.postInstall({ destDir, skills, scope, projectDir, homedir, force });
+
+    return {
+      adapterId: this.id,
+      adapterName: this.name,
+      destination: destDir,
+      installedCount: installedSkills.length,
+      skills: installedSkills,
+      postNotes: postNotes || null
+    };
+  }
+
+  async postInstall(context) {
+    return null;
+  }
+}

package/src/adapters/claude.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { BaseAdapter } from './base.js';
+
+export class ClaudeAdapter extends BaseAdapter {
+  constructor() {
+    super(
+      'claude-code',
+      'Claude Code CLI',
+      'Installs skills to ~/.claude/skills/ or .claude/skills/ for Claude Code'
+    );
+  }
+
+  resolveDestination({ scope, projectDir, homedir }) {
+    if (scope === 'global') {
+      return path.join(homedir, '.claude', 'skills');
+    }
+    return path.join(projectDir, '.claude', 'skills');
+  }
+
+  async postInstall({ scope, destDir }) {
+    if (scope === 'global') {
+      return `Claude Code will automatically recognize all skills globally from ${destDir}`;
+    }
+    return `Claude Code will automatically recognize all skills in this repository from ${destDir}`;
+  }
+}

package/src/adapters/opencode.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import process from 'node:process';
+import { BaseAdapter } from './base.js';
+
+export class OpenCodeAdapter extends BaseAdapter {
+  constructor() {
+    super(
+      'opencode',
+      'OpenCode',
+      'Installs skills to ~/.config/opencode/skills/ or .opencode/skills/'
+    );
+  }
+
+  resolveDestination({ scope, projectDir, homedir }) {
+    if (scope === 'global') {
+      if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(homedir, 'AppData', 'Roaming');
+        return path.join(appData, 'opencode', 'skills');
+      }
+      return path.join(homedir, '.config', 'opencode', 'skills');
+    }
+    return path.join(projectDir, '.opencode', 'skills');
+  }
+
+  async postInstall({ scope, destDir }) {
+    if (scope === 'global') {
+      return `OpenCode will load these skills globally from ${destDir}`;
+    }
+    return `OpenCode will load these skills in this workspace from ${destDir}`;
+  }
+}

package/src/adapters/vscode.js

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { BaseAdapter } from './base.js';
+
+export class VSCodeAdapter extends BaseAdapter {
+  constructor() {
+    super(
+      'vscode',
+      'VS Code (Copilot / Cline / Roo / Prompts)',
+      'Installs skills to .vscode/skills/ with Copilot & AI agent integration'
+    );
+  }
+
+  resolveDestination({ scope, projectDir, homedir }) {
+    if (scope === 'global') {
+      return path.join(homedir, '.vscode', 'skills');
+    }
+    return path.join(projectDir, '.vscode', 'skills');
+  }
+
+  async postInstall({ scope, projectDir, skills }) {
+    if (scope === 'project') {
+      try {
+        const githubDir = path.join(projectDir, '.github');
+        await this.ensureDir(githubDir);
+
+        const copilotInstructionsPath = path.join(githubDir, 'copilot-instructions.md');
+        let existingContent = '';
+        try {
+          existingContent = await fs.readFile(copilotInstructionsPath, 'utf8');
+        } catch {
+          // File does not exist yet
+        }
+
+        const marker = '<!-- FULLSTACK-SKILLS-INDEX-START -->';
+        const endMarker = '<!-- FULLSTACK-SKILLS-INDEX-END -->';
+
+        const skillList = skills.map((s) => `- **${s.name}**: \`.vscode/skills/${s.name}/SKILL.md\``).join('\n');
+        const section = `${marker}\n## Full-Stack AI Skills Library\n\nThe following engineering and design skills are installed in \`.vscode/skills/\`. Review and follow them when answering relevant engineering tasks:\n\n${skillList}\n${endMarker}`;
+
+        let newContent = '';
+        if (existingContent.includes(marker)) {
+          newContent = existingContent.replace(
+            new RegExp(`${marker}[\\s\\S]*?${endMarker}`),
+            section
+          );
+        } else {
+          newContent = existingContent
+            ? `${existingContent.trim()}\n\n${section}\n`
+            : `${section}\n`;
+        }
+
+        await fs.writeFile(copilotInstructionsPath, newContent, 'utf8');
+        return `Configured .vscode/skills/ and updated .github/copilot-instructions.md for Copilot & AI extensions`;
+      } catch (err) {
+        return `Installed to .vscode/skills/ (Could not update copilot-instructions: ${err.message})`;
+      }
+    }
+    return `Installed to global ~/.vscode/skills/`;
+  }
+}

package/src/compactor.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import zlib from 'node:zlib';
+import path from 'node:path';
+
+/**
+ * Native Node.js zlib gzip utilities for compacting skill packages
+ */
+export const compactor = {
+  /**
+   * Compresses a UTF-8 string or Buffer into a Gzip Buffer
+   */
+  compress(data) {
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
+    return zlib.gzipSync(buffer, { level: 9 });
+  },
+
+  /**
+   * Decompresses a Gzip Buffer into a UTF-8 string
+   */
+  decompress(buffer) {
+    return zlib.gunzipSync(buffer).toString('utf8');
+  },
+
+  /**
+   * Bundles an array of skills into a single gzipped JSON archive
+   */
+  async createBundle(skills) {
+    const bundleData = {};
+
+    for (const skill of skills) {
+      const skillFiles = {};
+      const entries = await fs.readdir(skill.path, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          const filePath = path.join(skill.path, entry.name);
+          skillFiles[entry.name] = await fs.readFile(filePath, 'utf8');
+        }
+      }
+
+      bundleData[skill.name] = {
+        name: skill.name,
+        category: skill.category,
+        description: skill.description,
+        files: skillFiles,
+      };
+    }
+
+    const json = JSON.stringify(bundleData);
+    const compressed = this.compress(json);
+
+    return {
+      compressed,
+      rawSizeBytes: Buffer.byteLength(json, 'utf8'),
+      compressedSizeBytes: compressed.length,
+      ratio: ((1 - compressed.length / Buffer.byteLength(json, 'utf8')) * 100).toFixed(1) + '%'
+    };
+  }
+};

package/src/flags.js

@@ -0,0 +1,123 @@
+const VALID_EDITORS = new Set(['claude-code', 'claude', 'antigravity', 'opencode', 'vscode', 'all']);
+const VALID_SCOPES = new Set(['project', 'global']);
+const VALID_BUNDLES = new Set(['fullstack', 'frontend', 'backend']);
+
+export function parseArgs(argv = []) {
+  const result = {
+    command: 'interactive',
+    editor: null,
+    scope: null,
+    bundle: null,
+    yes: false,
+    force: false,
+    list: false,
+    help: false,
+    version: false,
+    unknown: []
+  };
+
+  const args = [...argv];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === 'install') {
+      result.command = 'install';
+      continue;
+    }
+
+    if (arg === 'list') {
+      result.command = 'list';
+      result.list = true;
+      continue;
+    }
+
+    if (arg === '--help' || arg === '-h') {
+      result.help = true;
+      continue;
+    }
+
+    if (arg === '--version' || arg === '-v') {
+      result.version = true;
+      continue;
+    }
+
+    if (arg === '--list') {
+      result.list = true;
+      continue;
+    }
+
+    if (arg === '--yes' || arg === '-y') {
+      result.yes = true;
+      continue;
+    }
+
+    if (arg === '--force' || arg === '-f') {
+      result.force = true;
+      continue;
+    }
+
+    if (arg.startsWith('--editor=') || arg.startsWith('-e=')) {
+      const val = arg.split('=')[1];
+      result.editor = val;
+      continue;
+    }
+    if (arg === '--editor' || arg === '-e') {
+      result.editor = args[++i];
+      continue;
+    }
+
+    if (arg.startsWith('--scope=') || arg.startsWith('-s=')) {
+      const val = arg.split('=')[1];
+      result.scope = val;
+      continue;
+    }
+    if (arg === '--scope' || arg === '-s') {
+      result.scope = args[++i];
+      continue;
+    }
+
+    if (arg.startsWith('--bundle=') || arg.startsWith('-b=')) {
+      const val = arg.split('=')[1];
+      result.bundle = val;
+      continue;
+    }
+    if (arg === '--bundle' || arg === '-b') {
+      result.bundle = args[++i];
+      continue;
+    }
+
+    result.unknown.push(arg);
+  }
+
+  // Normalization & Validation
+  if (result.editor) {
+    result.editor = result.editor.toLowerCase();
+    if (result.editor === 'claude') result.editor = 'claude-code';
+    if (!VALID_EDITORS.has(result.editor)) {
+      throw new Error(`Invalid editor: "${result.editor}". Allowed values: claude-code, antigravity, opencode, vscode, all`);
+    }
+  }
+
+  if (result.scope) {
+    result.scope = result.scope.toLowerCase();
+    if (!VALID_SCOPES.has(result.scope)) {
+      throw new Error(`Invalid scope: "${result.scope}". Allowed values: project, global`);
+    }
+  }
+
+  if (result.bundle) {
+    result.bundle = result.bundle.toLowerCase();
+    if (!VALID_BUNDLES.has(result.bundle)) {
+      throw new Error(`Invalid bundle: "${result.bundle}". Allowed values: fullstack, frontend, backend`);
+    }
+  }
+
+  if (result.editor || result.scope || result.bundle) {
+    if (result.command === 'interactive') {
+      result.command = 'install';
+    }
+  }
+
+  return result;
+}

package/src/index.js

@@ -0,0 +1,9 @@
+export { installSkills, listSkills, getAdapters } from './installer.js';
+export { parseArgs } from './flags.js';
+export { ui } from './ui.js';
+export { compactor } from './compactor.js';
+export { BaseAdapter } from './adapters/base.js';
+export { ClaudeAdapter } from './adapters/claude.js';
+export { AntigravityAdapter } from './adapters/antigravity.js';
+export { OpenCodeAdapter } from './adapters/opencode.js';
+export { VSCodeAdapter } from './adapters/vscode.js';

package/src/installer.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { ClaudeAdapter } from './adapters/claude.js';
+import { AntigravityAdapter } from './adapters/antigravity.js';
+import { OpenCodeAdapter } from './adapters/opencode.js';
+import { VSCodeAdapter } from './adapters/vscode.js';
+
+import { compactor } from './compactor.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const SKILLS_DIR = path.join(PACKAGE_ROOT, 'skills');
+const BUNDLE_PATH = path.join(PACKAGE_ROOT, 'skills.bundle.json.gz');
+
+export function getAdapters() {
+  return {
+    'claude-code': new ClaudeAdapter(),
+    antigravity: new AntigravityAdapter(),
+    opencode: new OpenCodeAdapter(),
+    vscode: new VSCodeAdapter(),
+  };
+}
+
+export async function listSkills(skillsBaseDir = SKILLS_DIR, forceScan = false) {
+  if (!forceScan) {
+    try {
+      const compressed = await fs.readFile(BUNDLE_PATH);
+      const jsonStr = compactor.decompress(compressed);
+      const bundleData = JSON.parse(jsonStr);
+      const list = Object.values(bundleData);
+      if (list.length > 0) {
+        return list;
+      }
+    } catch {
+      // Fallback to directory scan
+    }
+  }
+
+  const skills = [];
+  const categories = ['backend', 'frontend'];
+
+  for (const cat of categories) {
+    const catDir = path.join(skillsBaseDir, cat);
+    try {
+      const entries = await fs.readdir(catDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillPath = path.join(catDir, entry.name);
+          const skillMdPath = path.join(skillPath, 'SKILL.md');
+
+          let description = '';
+          try {
+            const content = await fs.readFile(skillMdPath, 'utf8');
+            const match = content.match(/^---\s*[\r\n]+([\s\S]*?)[\r\n]+---/);
+            if (match) {
+              const yaml = match[1];
+              const descMatch = yaml.match(/description:\s*(?:>[-+]?|\|[-+]?)?\s*\n?((?:(?:\s{2,}|\t)[^\n\r]+(?:\r?\n|$))+|[^\n\r]+)/);
+              if (descMatch) {
+                description = descMatch[1]
+                  .split(/\r?\n/)
+                  .map((l) => l.trim())
+                  .filter(Boolean)
+                  .join(' ')
+                  .replace(/^['"]|['"]$/g, '');
+              }
+            }
+          } catch {
+            // ignore missing SKILL.md
+          }
+
+          skills.push({
+            name: entry.name,
+            category: cat,
+            path: skillPath,
+            description: description || 'Specialized full-stack development skill'
+          });
+        }
+      }
+    } catch {
+      // directory might not exist yet
+    }
+  }
+
+  return skills;
+}
+
+export async function installSkills({
+  editor = 'all',
+  scope = 'project',
+  bundle = 'fullstack',
+  projectDir = process.cwd(),
+  homedir,
+  force = false,
+  skillsBaseDir = SKILLS_DIR
+}) {
+  const allSkills = await listSkills(skillsBaseDir);
+
+  let selectedSkills = allSkills;
+  if (bundle === 'frontend') {
+    selectedSkills = allSkills.filter((s) => s.category === 'frontend');
+  } else if (bundle === 'backend') {
+    selectedSkills = allSkills.filter((s) => s.category === 'backend');
+  }
+
+  if (selectedSkills.length === 0) {
+    throw new Error(`No skills found for bundle: ${bundle}`);
+  }
+
+  const adaptersMap = getAdapters();
+  let targetAdapters = [];
+
+  if (editor === 'all') {
+    targetAdapters = Object.values(adaptersMap);
+  } else {
+    const adapter = adaptersMap[editor];
+    if (!adapter) {
+      throw new Error(`Unknown editor target: "${editor}"`);
+    }
+    targetAdapters = [adapter];
+  }
+
+  const results = [];
+
+  for (const adapter of targetAdapters) {
+    const res = await adapter.install({
+      skills: selectedSkills,
+      scope,
+      projectDir,
+      homedir,
+      force,
+    });
+    results.push(res);
+  }
+
+  return {
+    editor,
+    scope,
+    bundle,
+    selectedSkillsCount: selectedSkills.length,
+    results,
+  };
+}

package/src/ui.js

@@ -0,0 +1,158 @@
+import readline from 'node:readline';
+import process from 'node:process';
+
+// ANSI escape sequences
+export const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+};
+
+export const ui = {
+  banner() {
+    console.log(`\n${c.cyan}${c.bold}================================================================${c.reset}`);
+    console.log(`${c.cyan}${c.bold}  ⚡ fullstack-skills ${c.reset}${c.dim}v1.0.0${c.reset}`);
+    console.log(`  ${c.white}Universal AI Skills for Claude Code, Antigravity, OpenCode & VS Code${c.reset}`);
+    console.log(`${c.cyan}${c.bold}================================================================${c.reset}\n`);
+  },
+
+  info(msg) {
+    console.log(`${c.cyan}ℹ${c.reset} ${msg}`);
+  },
+
+  success(msg) {
+    console.log(`${c.green}${c.bold}✔${c.reset} ${msg}`);
+  },
+
+  warn(msg) {
+    console.log(`${c.yellow}${c.bold}▲${c.reset} ${msg}`);
+  },
+
+  error(msg) {
+    console.error(`${c.red}${c.bold}✖ Error:${c.reset} ${msg}`);
+  },
+
+  step(current, total, label) {
+    console.log(`\n${c.cyan}${c.bold}[${current}/${total}]${c.reset} ${c.bold}${label}${c.reset}`);
+  },
+
+  async confirm(promptText, defaultVal = true) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const suffix = defaultVal ? '[Y/n]' : '[y/N]';
+    return new Promise((resolve) => {
+      rl.question(`${promptText} ${c.dim}${suffix}${c.reset} `, (answer) => {
+        rl.close();
+        const trimmed = answer.trim().toLowerCase();
+        if (trimmed === '') return resolve(defaultVal);
+        resolve(trimmed === 'y' || trimmed === 'yes');
+      });
+    });
+  },
+
+  async select(title, choices, defaultIndex = 0) {
+    // If not a TTY or in non-interactive environment, use simple numeric prompt
+    if (!process.stdin.isTTY) {
+      return this._fallbackSelect(title, choices, defaultIndex);
+    }
+
+    return new Promise((resolve) => {
+      let selected = defaultIndex;
+      const stdin = process.stdin;
+      const stdout = process.stdout;
+
+      readline.emitKeypressEvents(stdin);
+      if (stdin.isTTY) {
+        stdin.setRawMode(true);
+      }
+
+      function render(firstTime = false) {
+        if (!firstTime) {
+          stdout.write(`\x1b[${choices.length}A`); // Move cursor up
+        }
+        for (let i = 0; i < choices.length; i++) {
+          const isSelected = i === selected;
+          const prefix = isSelected ? `${c.cyan}${c.bold}❯ ` : '  ';
+          const label = isSelected ? `${c.cyan}${c.bold}${choices[i].label}${c.reset}` : `${choices[i].label}`;
+          const desc = choices[i].desc ? ` ${c.dim}(${choices[i].desc})${c.reset}` : '';
+          stdout.write(`\x1b[2K${prefix}${label}${desc}\n`); // Clear line and write
+        }
+      }
+
+      render(true);
+
+      function cleanup() {
+        if (stdin.isTTY) {
+          stdin.setRawMode(false);
+        }
+        stdin.removeListener('keypress', onKeypress);
+      }
+
+      function onKeypress(str, key) {
+        if (key.ctrl && key.name === 'c') {
+          cleanup();
+          process.exit(130);
+        }
+
+        if (key.name === 'up' || (key.name === 'k')) {
+          selected = selected > 0 ? selected - 1 : choices.length - 1;
+          render(false);
+        } else if (key.name === 'down' || (key.name === 'j')) {
+          selected = selected < choices.length - 1 ? selected + 1 : 0;
+          render(false);
+        } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
+          cleanup();
+          stdout.write('\n');
+          resolve(choices[selected].value);
+        } else if (/^[1-9]$/.test(str)) {
+          const num = parseInt(str, 10) - 1;
+          if (num >= 0 && num < choices.length) {
+            selected = num;
+            render(false);
+          }
+        }
+      }
+
+      stdin.on('keypress', onKeypress);
+      stdin.resume();
+    });
+  },
+
+  async _fallbackSelect(title, choices, defaultIndex = 0) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    console.log(title);
+    choices.forEach((choice, idx) => {
+      const isDefault = idx === defaultIndex ? ' [default]' : '';
+      console.log(`  ${idx + 1}. ${choice.label}${choice.desc ? ` (${choice.desc})` : ''}${isDefault}`);
+    });
+
+    return new Promise((resolve) => {
+      rl.question(`Select option (1-${choices.length}): `, (answer) => {
+        rl.close();
+        const num = parseInt(answer.trim(), 10);
+        if (num >= 1 && num <= choices.length) {
+          resolve(choices[num - 1].value);
+        } else {
+          resolve(choices[defaultIndex].value);
+        }
+      });
+    });
+  }
+};