kenmark-skills 1.0.0 → 1.0.2

package/README.md

@@ -26,37 +26,61 @@ These skills assume a **`brain/`** knowledge base (standards, changelog, optiona
 
 ## Install
 
-### Option A — Clone into your skills directory
-
-**Cursor (user-level):**
+### Option A — Global npm install (recommended)
 
 ```bash
-git clone https://github.com/TanoojMehra/kenmark-skills.git
-cp -R kenmark-skills/skills/user-skills/* ~/.cursor/skills/
+npm install -g kenmark-skills
+npx kenmark-skills setup
 ```
 
-**Codex / shared agent skills (`~/.agents/skills`):**
+`npx kenmark-skills setup` (or `kenmark-skills-setup`) auto-detects your platform and copies skills to detected global IDE paths:
+
+- Cursor: `~/.cursor/skills`
+- Codex/shared agents: `~/.agents/skills`
+- Claude Code: `~/.claude/skills`
+- Gemini CLI: `~/.gemini/skills`
+- OpenCode: `~/.opencode/skills`
+- Kiro: `~/.kiro/skills`
+- Trae: `~/.trae/skills` / `~/.trae-cn/skills`
+- Rovo Dev: `~/.rovodev/skills`
+- Qoder: `~/.qoder/skills`
+
+For Claude Code specifically, setup also installs slash-command wrappers in `~/.claude/commands`:
+
+- `/kenmark-init-brain`
+- `/kenmark-commit-push`
+- `/kenmark-issues-list` (and matching wrappers for all shipped skills)
+
+Useful flags:
 
 ```bash
-cp -R kenmark-skills/skills/user-skills/* ~/.agents/skills/
+npx kenmark-skills setup --ide cursor
+npx kenmark-skills setup --ide codex
+npx kenmark-skills setup --ide claude
+npx kenmark-skills setup --ide gemini
+npx kenmark-skills setup --ide all
 ```
 
-**Project-scoped (team repo):**
+### Option B — Local/project install with npx (no global install)
 
 ```bash
-mkdir -p .cursor/skills
-cp -R /path/to/kenmark-skills/skills/user-skills/* .cursor/skills/
+npx kenmark-skills setup --project
 ```
 
-Commit project-scoped skills only if the whole team should use the same versions.
+For project-local installation (repo-scoped skill folders), use:
+
+```bash
+npx kenmark-skills setup --project
+npx kenmark-skills setup --project --ide all
+```
 
-### Option B — npm package
+Use `--global` to force user-level install mode explicitly:
 
 ```bash
-npm install kenmark-skills
+npx kenmark-skills setup --global --ide all
 ```
 
-Published files live under `node_modules/kenmark-skills/skills/user-skills/`. Copy that folder into `~/.cursor/skills/`, `~/.agents/skills/`, or your project's skills path (same as Option A).
+If new Claude slash commands do not appear immediately, restart Claude Code.
 
 Verify what will ship before publishing:
 

package/brain/CHANGELOG.md

@@ -1,5 +1,26 @@
 # CHANGELOG
 
+## v2026.06.02-1938-claude-command-wrappers
+- Updated setup installer to generate Claude Code slash-command wrappers under `.claude/commands` for every shipped Kenmark skill.
+- This enables direct slash usage (for example `/kenmark-init-brain`) in addition to selecting skills from `/skills`.
+- Updated README to document Claude wrapper commands and restart note.
+
+## v2026.06.02-1930-readme-npx-first-install
+- Updated README install guidance to remove the clone-based setup path.
+- Reframed Option B as local/project installation via `npx kenmark-skills setup --project`.
+- Kept install flow focused on global npm install and npx-based usage.
+
+## v2026.06.02-1925-cli-setup-modes-targets
+- Added package CLI entrypoint so setup can run as `npx kenmark-skills setup` (plus existing `kenmark-skills-setup` bin).
+- Expanded setup script to support install modes: `--global` (default) and `--project`.
+- Added broader harness target mappings: Cursor, Codex, Claude, Gemini, OpenCode, Kiro, Trae (`trae` and `trae-cn`), Rovo, and Qoder.
+- Updated README install docs with new command syntax, install modes, and expanded target list.
+
+## v2026.06.02-1920-global-setup-script
+- Updated install docs so Option A is now global npm install with a one-command setup flow.
+- Added `scripts/setup-skills.js` to auto-copy packaged skills to detected IDE paths (`~/.cursor/skills`, `~/.agents/skills`, `~/.claude/skills`) with `--ide` override flags.
+- Wired setup into `package.json` via `setup:skills` script and global `kenmark-skills-setup` bin.
+
 ## v2026.06.02-1912-init-brain-user-choice
 - init-brain now asks which agent config files to sync instead of creating all targets by default.
 - Brain scaffold still always runs; only user-selected files (CLAUDE.md, AGENTS.md, Cursor, GEMINI.md) are written.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kenmark-skills",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Skills by Kenmark ITan Solutions — Cursor/Codex agent skills from our development workflows. Created by Tanooj Mehra & Adwait Date.",
   "license": "MIT",
   "private": false,
@@ -9,12 +9,20 @@
     "skills/user-skills/**/*",
     "skills/user-skills-manifest.md",
     "skills/COPIED_SKILLS.md",
-    "brain/CHANGELOG.md"
+    "brain/CHANGELOG.md",
+    "scripts/setup-skills.js",
+    "scripts/cli.js"
   ],
   "scripts": {
+    "setup": "node scripts/cli.js setup",
+    "setup:skills": "node scripts/setup-skills.js",
     "pack:check": "npm pack --dry-run",
     "publish:public": "npm publish --access public"
   },
+  "bin": {
+    "kenmark-skills": "scripts/cli.js",
+    "kenmark-skills-setup": "scripts/setup-skills.js"
+  },
   "keywords": [
     "kenmark",
     "cursor",

package/scripts/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function printUsage() {
+  console.log("kenmark-skills CLI");
+  console.log("");
+  console.log("Usage:");
+  console.log("  kenmark-skills setup [--global|--project] [--ide <target>]");
+  console.log("  kenmark-skills help");
+  console.log("");
+  console.log("Examples:");
+  console.log("  npx kenmark-skills setup");
+  console.log("  npx kenmark-skills setup --project --ide cursor");
+  console.log("  npx kenmark-skills setup --global --ide all");
+}
+
+if (!command || command === "help" || command === "--help" || command === "-h") {
+  printUsage();
+  process.exit(0);
+}
+
+if (command === "setup") {
+  const scriptPath = path.join(__dirname, "setup-skills.js");
+  const forwardedArgs = args.slice(1);
+  const result = spawnSync(process.execPath, [scriptPath, ...forwardedArgs], {
+    stdio: "inherit"
+  });
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+console.error(`Unknown command: ${command}`);
+printUsage();
+process.exit(1);

package/scripts/setup-skills.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const homeDir = os.homedir();
+const projectDir = process.cwd();
+const repoRoot = path.resolve(__dirname, "..");
+const sourceDir = path.join(repoRoot, "skills", "user-skills");
+
+const globalTargets = {
+  cursor: path.join(homeDir, ".cursor", "skills"),
+  codex: path.join(homeDir, ".agents", "skills"),
+  claude: path.join(homeDir, ".claude", "skills"),
+  gemini: path.join(homeDir, ".gemini", "skills"),
+  opencode: path.join(homeDir, ".opencode", "skills"),
+  kiro: path.join(homeDir, ".kiro", "skills"),
+  trae: path.join(homeDir, ".trae", "skills"),
+  "trae-cn": path.join(homeDir, ".trae-cn", "skills"),
+  rovo: path.join(homeDir, ".rovodev", "skills"),
+  qoder: path.join(homeDir, ".qoder", "skills")
+};
+
+const projectTargets = {
+  cursor: path.join(projectDir, ".cursor", "skills"),
+  codex: path.join(projectDir, ".agents", "skills"),
+  claude: path.join(projectDir, ".claude", "skills"),
+  gemini: path.join(projectDir, ".gemini", "skills"),
+  opencode: path.join(projectDir, ".opencode", "skills"),
+  kiro: path.join(projectDir, ".kiro", "skills"),
+  trae: path.join(projectDir, ".trae", "skills"),
+  "trae-cn": path.join(projectDir, ".trae-cn", "skills"),
+  rovo: path.join(projectDir, ".rovodev", "skills"),
+  qoder: path.join(projectDir, ".qoder", "skills")
+};
+
+function printUsage() {
+  console.log("Usage: kenmark-skills-setup [--global|--project] [--ide <target>]");
+  console.log("Targets: cursor, codex, claude, gemini, opencode, kiro, trae, trae-cn, rovo, qoder, all");
+  console.log("Examples:");
+  console.log("  kenmark-skills-setup");
+  console.log("  kenmark-skills-setup --ide cursor");
+  console.log("  kenmark-skills-setup --project --ide all");
+  console.log("  npx kenmark-skills setup --global --ide gemini");
+  console.log("  npm run setup:skills -- --ide all");
+}
+
+function parseArgs(argv) {
+  const args = { ide: null, mode: "global" };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--help" || token === "-h") {
+      args.help = true;
+      continue;
+    }
+    if (token === "--ide") {
+      args.ide = argv[i + 1] || null;
+      i += 1;
+      continue;
+    }
+    if (token === "--project") {
+      args.mode = "project";
+      continue;
+    }
+    if (token === "--global") {
+      args.mode = "global";
+      continue;
+    }
+  }
+  return args;
+}
+
+function detectInstalledIdes(targetMap) {
+  const detected = [];
+  for (const [ide, targetPath] of Object.entries(targetMap)) {
+    const parent = path.dirname(targetPath);
+    if (fs.existsSync(parent)) {
+      detected.push(ide);
+    }
+  }
+  return detected;
+}
+
+function ensureTargetPath(targetPath) {
+  fs.mkdirSync(targetPath, { recursive: true });
+}
+
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function copyDirectoryContents(sourcePath, targetPath) {
+  const entries = fs.readdirSync(sourcePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourceEntryPath = path.join(sourcePath, entry.name);
+    const targetEntryPath = path.join(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      fs.rmSync(targetEntryPath, { recursive: true, force: true });
+      fs.cpSync(sourceEntryPath, targetEntryPath, { recursive: true });
+    } else if (entry.isFile()) {
+      fs.copyFileSync(sourceEntryPath, targetEntryPath);
+    }
+  }
+}
+
+function createClaudeCommandWrappers(basePath) {
+  const commandsDir = path.join(path.dirname(basePath), "commands");
+  const skills = fs
+    .readdirSync(sourceDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
+
+  for (const skillName of skills) {
+    const commandFile = path.join(commandsDir, `kenmark-${skillName}.md`);
+    const commandBody = [
+      `# Kenmark ${skillName}`,
+      "",
+      `Use the \`${skillName}\` skill from installed user skills.`,
+      "",
+      "Instructions:",
+      `- Invoke and follow the \`${skillName}\` skill from the user skills directory.`,
+      "- Execute the skill workflow end-to-end for the current request.",
+      "- If required context is missing, ask concise clarifying questions first."
+    ].join("\n");
+    ensureParentDir(commandFile);
+    fs.writeFileSync(commandFile, `${commandBody}\n`, "utf8");
+  }
+
+  return { commandsDir, count: skills.length };
+}
+
+function run() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printUsage();
+    process.exit(0);
+  }
+
+  if (!fs.existsSync(sourceDir)) {
+    console.error(`Source skills directory missing: ${sourceDir}`);
+    process.exit(1);
+  }
+
+  const targetMap = args.mode === "project" ? projectTargets : globalTargets;
+  const requestedIde = args.ide ? String(args.ide).toLowerCase() : null;
+  let targetIdes = [];
+
+  if (requestedIde) {
+    if (requestedIde === "all") {
+      targetIdes = Object.keys(targetMap);
+    } else if (targetMap[requestedIde]) {
+      targetIdes = [requestedIde];
+    } else {
+      console.error(`Unknown --ide value: ${args.ide}`);
+      printUsage();
+      process.exit(1);
+    }
+  } else {
+    targetIdes = detectInstalledIdes(targetMap);
+    if (targetIdes.length === 0) {
+      targetIdes = ["cursor"];
+      if (args.mode === "project") {
+        console.log("No known project skill directories found. Defaulting to .cursor/skills.");
+      } else {
+        console.log("No known global IDE config directories found. Defaulting to ~/.cursor/skills.");
+      }
+    }
+  }
+
+  console.log(`Operating system: ${process.platform}`);
+  console.log(`Install mode: ${args.mode}`);
+  console.log(`Installing skills from: ${sourceDir}`);
+
+  for (const ide of targetIdes) {
+    const targetPath = targetMap[ide];
+    ensureTargetPath(targetPath);
+    copyDirectoryContents(sourceDir, targetPath);
+    console.log(`Installed skills for ${ide}: ${targetPath}`);
+    if (ide === "claude") {
+      const result = createClaudeCommandWrappers(targetPath);
+      console.log(
+        `Installed Claude command wrappers (${result.count}): ${result.commandsDir}`
+      );
+    }
+  }
+
+  console.log("Done.");
+}
+
+run();