vector-cadence-skills 0.1.0 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.3
+
+- Updated folder target configurations for Codex CLI (`.codex/skills`), OpenCode (`.opencode/skills`), Pi (`.pi/skills`), and Claude Code (`CLAUDE.md`).
+
+## 0.1.2
+
+- Expanded installer to support deploying rules to various agent environments: Cursor, Claude Code, Pi/Codex, and Oh-My-Pi/OpenCode.
+
+## 0.1.1
+
+- Added installation CLI binary (`scripts/bin.js`) and `plugin.json` for NPM package distribution.
+
 ## 0.1.0
 
 - Added initial production-ready Vector Cadence integrated skill suite.

package/DOCUMENTATION.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-This document describes the finalized production-oriented Vector Cadence skill suite in `skills/vc-integrated-skills/`.
+This document describes the finalized production-oriented Vector Cadence skill suite in the `skills/` directory.
 
 The suite started as an integration of Matt Pocock’s engineering skills and Compound Engineering’s skills, but the final version no longer exposes that integration history inside each runtime skill. Runtime skills are now concise operating procedures. Source comparisons, rationale, and architecture decisions live in documentation and reference files.
 
@@ -852,10 +852,10 @@ Important references:
 Validation command from the workspace root used in this environment:
 
 ```bash
-node vc-integrated-skills/scripts/validate-skills.mjs
+npm run validate
 ```
 
-If running from inside `vc-integrated-skills`, this also works:
+Or:
 
 ```bash
 node scripts/validate-skills.mjs
@@ -974,20 +974,18 @@ Use `references/source-integration-map.md` to explain upstream sources and integ
 
 ### 17.4 Run validation before publishing
 
-Run:
+From the project root directory, run:
 
 ```bash
-node scripts/validate-skills.mjs
+npm run validate
 ```
 
-from inside `vc-integrated-skills`, or:
+Or:
 
 ```bash
-node vc-integrated-skills/scripts/validate-skills.mjs
+node scripts/validate-skills.mjs
 ```
 
-from the parent directory.
-
 ### 17.5 Keep examples small
 
 Examples should teach behavior, not become huge tutorials.
@@ -1017,9 +1015,9 @@ Includes:
 - changelog,
 - contributing guide.
 
-### Phase 2: Package as `vc-skills`
+### Phase 2: Package as `vc-skills` (Completed)
 
-Add package metadata and installer assumptions once the target harness format is chosen.
+Completed adding package metadata (`package.json`, `plugin.json`, `skills.json`) and an installer CLI (`scripts/bin.js`) to support Cursor, Claude Code, Pi, Codex, OpenCode, and Oh-My-Pi targets.
 
 ### Phase 3: Build `vc-extensions`
 
@@ -1069,7 +1067,7 @@ The final skill suite is now in the shape it should be for a publishable skill p
 
 The next best step is not more skill editing. The next best step is packaging and harness implementation:
 
-1. Treat `vc-integrated-skills` as the seed for `@your-scope/vc-skills`.
+1. Treat `vector-cadence-skills` as the seed for `@your-scope/vc-skills`.
 2. Build `vc-extensions` for actual tools.
 3. Build a thin pi-first `vc-cli` wrapper.
 4. Keep Reasonix/cache-first work behind telemetry and measurement.

package/README.md

@@ -2,6 +2,30 @@
 
 Vector Cadence Skills is a production-ready skill suite for agentic software engineering workflows. It integrates the useful disciplines from Matt Pocock’s skills and Compound Engineering without making runtime skills depend on upstream command names or block-by-block composition.
 
+## Setup
+
+Install globally using `npm`:
+```bash
+npm install -g vector-cadence-skills
+```
+Or execute the installer directly using `npx`:
+```bash
+npx vc-skills
+```
+
+By default, executing `npx vc-skills` without arguments installs the skills globally to your **Antigravity** plugin config. 
+
+To deploy rules and skills locally to other agent environments in your current project folder, run:
+```bash
+npx vc-skills --cursor       # Cursor rules (.cursor/rules/)
+npx vc-skills --claude       # Claude Code skills (.claude/skills/)
+npx vc-skills --codex        # Codex CLI skills (.codex/skills/)
+npx vc-skills --opencode     # OpenCode skills (.opencode/skills/)
+npx vc-skills --pi           # Pi skills (.pi/skills/)
+npx vc-skills --omp          # Oh-My-Pi skills (.omp/skills/)
+npx vc-skills --all          # Deploys to all local environments simultaneously
+```
+
 ## Core idea
 
 Each skill owns one lifecycle responsibility:
@@ -96,11 +120,43 @@ templates/AGENTS.md
 templates/CONTEXT.md
 templates/vc-budget.yml
 scripts/validate-skills.mjs
+scripts/bin.js
 skills.json
 examples/
 references/
 ```
 
+## Installation & Deployment
+
+Vector Cadence Skills can be installed globally as an npm package or executed directly to deploy rules and skills to various local development agent environments.
+
+### 1. Global Installation (Antigravity)
+By default, running the installer without arguments copies all skills and assets to the Antigravity global plugins directory:
+
+```bash
+# Install dependencies first
+npm install
+
+# Run the installer to deploy to Antigravity global config
+node scripts/bin.js
+
+# Or if installed globally / via npx:
+npx vc-skills
+```
+
+### 2. Deploying to Local Agent Tools
+You can deploy the skills as configuration rules directly to local agent environments in your active project directory. Use the corresponding CLI flags:
+
+| Target Environment | CLI Command | Target Location | Description |
+|---|---|---|---|
+| **Cursor** | `npx vc-skills --cursor` | `.cursor/rules/vc-*.md` | Deploys skills as Cursor rules |
+| **Claude Code** | `npx vc-skills --claude` | `.claude/skills/vc-*/` | Deploys skill directories and a lightweight starter `CLAUDE.md` to Claude Code |
+| **Codex CLI** | `npx vc-skills --codex` | `.codex/skills/vc-*/` | Deploys skill directories to Codex |
+| **OpenCode** | `npx vc-skills --opencode` | `.opencode/skills/vc-*/` | Deploys skill directories to OpenCode |
+| **Pi** | `npx vc-skills --pi` | `.pi/skills/vc-*/` | Deploys skill directories to Pi |
+| **Oh-My-Pi** | `npx vc-skills --omp` | `.omp/skills/vc-*/` | Deploys skill directories to Oh-My-Pi |
+| **All targets** | `npx vc-skills --all` | (All of the above) | Deploys to all local targets simultaneously |
+
 ## Validation
 
 From this directory, run:

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "vector-cadence-skills",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "description": "Integrated Vector Cadence skill suite for agentic software engineering workflows.",
   "main": "skills.json",
+  "bin": {
+    "vc-skills": "scripts/bin.js"
+  },
   "scripts": {
     "validate": "node scripts/validate-skills.mjs"
   },
@@ -31,6 +34,7 @@
     "scripts",
     "templates",
     "skills.json",
+    "plugin.json",
     "README.md",
     "DOCUMENTATION.md",
     "CHANGELOG.md",

package/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "vector-cadence-skills",
+  "version": "0.1.1",
+  "description": "Integrated Vector Cadence skill suite for agentic software engineering workflows.",
+  "author": {
+    "name": "Mithil Yaganti"
+  },
+  "license": "Apache-2.0",
+  "keywords": [
+    "vector-cadence",
+    "skills",
+    "software-engineering",
+    "agentic"
+  ]
+}

package/references/architecture-overview.md

@@ -1,6 +1,6 @@
 # Vector Cadence Skills — Architecture Overview
 
-This is the short architecture document for the new skill suite. It is intentionally smaller than the full research documentation. The full documentation can be written later when requested.
+This is the short architecture document for the new skill suite. The full, comprehensive documentation can be found in [DOCUMENTATION.md](file:///c:/Users/mithi/Desktop/mithil/skills/DOCUMENTATION.md).
 
 ## 1. What changed from the original Vector Cadence document
 

package/scripts/bin.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Source directory (root of the package)
+const packageRootDir = path.resolve(__dirname, '..');
+
+// Helper to copy directory recursively
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (let entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// Installation Targets
+function installToAntigravity() {
+  const homeDir = os.homedir();
+  const pluginsDir = path.join(homeDir, '.gemini', 'config', 'plugins');
+  const targetDir = path.join(pluginsDir, 'vector-cadence-skills');
+
+  console.log('Installing to Antigravity (global)...');
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  const itemsToCopy = [
+    'skills', 'examples', 'references', 'scripts', 'templates',
+    'skills.json', 'plugin.json', 'README.md', 'DOCUMENTATION.md',
+    'CHANGELOG.md', 'CONTRIBUTING.md'
+  ];
+
+  for (const item of itemsToCopy) {
+    const srcPath = path.join(packageRootDir, item);
+    const destPath = path.join(targetDir, item);
+
+    if (!fs.existsSync(srcPath)) continue;
+
+    const stats = fs.statSync(srcPath);
+    if (stats.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+  console.log(`- Installed successfully to Antigravity global plugins: ${targetDir}`);
+}
+
+function installToCursor() {
+  const destDir = path.join(process.cwd(), '.cursor', 'rules');
+  console.log('Installing to Cursor (.cursor/rules/)...');
+  fs.mkdirSync(destDir, { recursive: true });
+  
+  const skillsDir = path.join(packageRootDir, 'skills');
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  
+  for (let entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith('vc-')) {
+      const srcFile = path.join(skillsDir, entry.name, 'SKILL.md');
+      const destFile = path.join(destDir, `${entry.name}.md`);
+      if (fs.existsSync(srcFile)) {
+        fs.copyFileSync(srcFile, destFile);
+        console.log(`- Created Cursor rule: .cursor/rules/${entry.name}.md`);
+      }
+    }
+  }
+}
+
+function installToClaude() {
+  const destDir = path.join(process.cwd(), '.claude', 'skills');
+  console.log('Installing to Claude Code (.claude/skills/)...');
+  fs.mkdirSync(destDir, { recursive: true });
+  
+  const skillsDir = path.join(packageRootDir, 'skills');
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  
+  for (let entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith('vc-')) {
+      copyDir(path.join(skillsDir, entry.name), path.join(destDir, entry.name));
+      console.log(`- Created skill folder: .claude/skills/${entry.name}`);
+    }
+  }
+
+  // Create a lightweight CLAUDE.md template if it does not already exist
+  const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+  if (!fs.existsSync(claudeMdPath)) {
+    const defaultClaudeMd = `# Project Rules
+
+## Build, Test, and Lint Commands
+# Add your project-specific commands here, e.g.:
+# npm run dev
+# npm run test
+
+## Vector Cadence Skills
+Skills are installed locally at \`.claude/skills/\` and are automatically available as slash commands (e.g. \`/vc-align\`, \`/vc-execute\`).
+`;
+    fs.writeFileSync(claudeMdPath, defaultClaudeMd, 'utf8');
+    console.log('- Created starter CLAUDE.md at project root.');
+  }
+}
+
+function installToCodex() {
+  const destDir = path.join(process.cwd(), '.codex', 'skills');
+  console.log('Installing to Codex CLI (.codex/skills/)...');
+  fs.mkdirSync(destDir, { recursive: true });
+  
+  const skillsDir = path.join(packageRootDir, 'skills');
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  
+  for (let entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith('vc-')) {
+      copyDir(path.join(skillsDir, entry.name), path.join(destDir, entry.name));
+      console.log(`- Created skill folder: .codex/skills/${entry.name}`);
+    }
+  }
+}
+
+function installToOpenCode() {
+  const destDir = path.join(process.cwd(), '.opencode', 'skills');
+  console.log('Installing to OpenCode (.opencode/skills/)...');
+  fs.mkdirSync(destDir, { recursive: true });
+  
+  const skillsDir = path.join(packageRootDir, 'skills');
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  
+  for (let entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith('vc-')) {
+      copyDir(path.join(skillsDir, entry.name), path.join(destDir, entry.name));
+      console.log(`- Created skill folder: .opencode/skills/${entry.name}`);
+    }
+  }
+}
+
+function installToPi() {
+  const destDir = path.join(process.cwd(), '.pi', 'skills');
+  console.log('Installing to Pi (.pi/skills/)...');
+  fs.mkdirSync(destDir, { recursive: true });
+  
+  const skillsDir = path.join(packageRootDir, 'skills');
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  
+  for (let entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith('vc-')) {
+      copyDir(path.join(skillsDir, entry.name), path.join(destDir, entry.name));
+      console.log(`- Created skill folder: .pi/skills/${entry.name}`);
+    }
+  }
+}
+
+function installToOmp() {
+  const destDir = path.join(process.cwd(), '.omp', 'skills');
+  console.log('Installing to Oh-My-Pi (.omp/skills/)...');
+  fs.mkdirSync(destDir, { recursive: true });
+  
+  const skillsDir = path.join(packageRootDir, 'skills');
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  
+  for (let entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith('vc-')) {
+      copyDir(path.join(skillsDir, entry.name), path.join(destDir, entry.name));
+      console.log(`- Created skill folder: .omp/skills/${entry.name}`);
+    }
+  }
+}
+
+// CLI Execution Flow
+const args = process.argv.slice(2);
+const isAll = args.includes('--all');
+const isCursor = args.includes('--cursor') || isAll;
+const isClaude = args.includes('--claude') || args.includes('--claude-code') || isAll;
+const isCodex = args.includes('--codex') || args.includes('--codex-cli') || isAll;
+const isOpenCode = args.includes('--opencode') || isAll;
+const isPi = args.includes('--pi') || isAll;
+const isOmp = args.includes('--omp') || args.includes('--oh-my-pi') || isAll;
+const isAntigravity = args.includes('--antigravity') || args.length === 0;
+
+console.log('=== Vector Cadence Skills Installer ===\n');
+
+try {
+  let executed = false;
+
+  if (isAntigravity) {
+    installToAntigravity();
+    executed = true;
+  }
+  if (isCursor) {
+    installToCursor();
+    executed = true;
+  }
+  if (isClaude) {
+    installToClaude();
+    executed = true;
+  }
+  if (isCodex) {
+    installToCodex();
+    executed = true;
+  }
+  if (isOpenCode) {
+    installToOpenCode();
+    executed = true;
+  }
+  if (isPi) {
+    installToPi();
+    executed = true;
+  }
+  if (isOmp) {
+    installToOmp();
+    executed = true;
+  }
+
+  if (executed) {
+    console.log('\nInstallation completed successfully!');
+  } else {
+    console.log('No valid installation target specified.');
+  }
+
+  // Print helpful tip if default global run
+  if (args.length === 0) {
+    console.log('\n---');
+    console.log('Tip: You can also deploy the skills locally to other agent tools in this project folder:');
+    console.log('  npx vector-cadence-skills --cursor       (Cursor rules)');
+    console.log('  npx vector-cadence-skills --claude       (Claude Code CLI rules)');
+    console.log('  npx vector-cadence-skills --codex        (Codex CLI skills)');
+    console.log('  npx vector-cadence-skills --opencode     (OpenCode skills)');
+    console.log('  npx vector-cadence-skills --pi           (Pi skills)');
+    console.log('  npx vector-cadence-skills --omp          (Oh-My-Pi skills)');
+    console.log('  npx vector-cadence-skills --all          (Install to all local project tools)');
+  }
+} catch (error) {
+  console.error('\nInstallation failed:', error.message);
+  process.exit(1);
+}

package/scripts/validate-skills.mjs

@@ -168,6 +168,14 @@ for (const file of skillFiles) {
 }
 
 for (const file of fs.readdirSync(root, { recursive: true })) {
+  const filePathStr = file.toString().replaceAll("\\", "/");
+  if (
+    filePathStr.includes("node_modules") ||
+    filePathStr.includes(".git") ||
+    path.basename(filePathStr).startsWith("session-")
+  ) {
+    continue;
+  }
   const full = path.join(root, file.toString());
   if (exists(full) && fs.statSync(full).isFile() && full.endsWith(".md")) {
     checkLinks(full, read(full));