@josui/cli 0.1.1

package/README.md

@@ -0,0 +1,75 @@
+# @josui/cli
+
+CLI tool for linking josui packages and skills to external projects.
+
+## Installation
+
+```bash
+pnpm add @josui/cli
+```
+
+## Usage
+
+```bash
+pnpm josui link packages
+pnpm josui link skills
+```
+
+Or with npx:
+
+```bash
+npx josui link packages
+```
+
+### Running from source
+
+If you're developing josui locally, you can run the CLI directly:
+
+```bash
+node <path-to-josui>/packages/cli/dist/index.js
+```
+
+Replace `<path-to-josui>` with the relative path to your josui checkout (e.g., `../josui`).
+
+## Commands
+
+### Link packages
+
+Link `@josui/*` packages from your local josui checkout:
+
+```bash
+josui link packages
+```
+
+This replaces npm-installed packages in `node_modules/@josui/` with symlinks to your local josui packages, enabling hot reload during development.
+
+### Link skills
+
+Link Claude Code skills from josui packages:
+
+```bash
+josui link skills
+```
+
+This creates symlinks in `.claude/skills/` for selected skills from josui packages.
+
+## Configuration
+
+The CLI saves your settings to `.josui.json` in your project root:
+
+```json
+{
+  "josuiPath": "../josui",
+  "linkedPackages": ["core", "core-web", "react", "tailwind", "tokens"],
+  "linkedSkills": [{ "source": "react", "skills": ["use-react-components"] }]
+}
+```
+
+When you run the CLI again, it offers to re-link using the saved config.
+
+## How It Works
+
+1. `pnpm install` creates a clean lockfile with npm versions
+2. The CLI replaces `node_modules/@josui/*` with symlinks to local packages
+3. The lockfile stays unchanged — CI works with the committed lockfile
+4. Config is saved for quick re-linking after future installs

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { select as select3 } from "@inquirer/prompts";
+
+// src/commands/link-packages.ts
+import { input, select, checkbox } from "@inquirer/prompts";
+import { existsSync as existsSync2 } from "fs";
+import { rm, symlink, mkdir } from "fs/promises";
+import { join as join2, relative } from "path";
+
+// src/utils/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+var GITIGNORE_ENTRIES = ["# josui local linking config", ".josui.json", "josui-linked-*"];
+var CONFIG_FILE = ".josui.json";
+function getConfigPath(cwd = process.cwd()) {
+  return join(cwd, CONFIG_FILE);
+}
+async function readConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeConfig(config, cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+async function updateConfig(updates, cwd = process.cwd()) {
+  const existing = await readConfig(cwd) || {};
+  const updated = { ...existing, ...updates };
+  await writeConfig(updated, cwd);
+  return updated;
+}
+async function ensureGitignore(cwd = process.cwd()) {
+  const gitignorePath = join(cwd, ".gitignore");
+  const content = existsSync(gitignorePath) ? await readFile(gitignorePath, "utf-8") : "";
+  const entriesToCheck = GITIGNORE_ENTRIES.filter((e) => !e.startsWith("#"));
+  const missingEntries = entriesToCheck.filter((entry) => !content.includes(entry));
+  if (missingEntries.length === 0) {
+    return false;
+  }
+  const toAdd = missingEntries.length === entriesToCheck.length ? GITIGNORE_ENTRIES : missingEntries;
+  const prefix = content.length > 0 && !content.endsWith("\n\n") ? content.endsWith("\n") ? "\n" : "\n\n" : "";
+  await writeFile(gitignorePath, content + prefix + toAdd.join("\n") + "\n");
+  return true;
+}
+
+// src/commands/link-packages.ts
+var AVAILABLE_PACKAGES = ["core", "core-web", "react", "tailwind", "tokens"];
+async function linkPackages() {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (config?.josuiPath && config?.linkedPackages?.length) {
+    const action = await select({
+      message: "Found existing configuration. What would you like to do?",
+      choices: [
+        { value: "relink", name: "Re-link existing packages" },
+        { value: "modify", name: "Add or remove packages" },
+        { value: "fresh", name: "Start fresh" }
+      ]
+    });
+    if (action === "relink") {
+      await performLink(cwd, config.josuiPath, config.linkedPackages);
+      return;
+    }
+    if (action === "fresh") {
+    } else {
+      const packages2 = await checkbox({
+        message: "Select packages to link:",
+        choices: AVAILABLE_PACKAGES.map((pkg) => ({
+          value: pkg,
+          name: `@josui/${pkg}`,
+          checked: config.linkedPackages?.includes(pkg)
+        }))
+      });
+      if (packages2.length === 0) {
+        console.log("No packages selected. Exiting.");
+        return;
+      }
+      await updateConfig({ linkedPackages: packages2 }, cwd);
+      await performLink(cwd, config.josuiPath, packages2);
+      return;
+    }
+  }
+  const defaultPath = config?.josuiPath || "../josui";
+  const josuiPath = await input({
+    message: "Where is your josui monorepo?",
+    default: defaultPath,
+    validate: (value) => {
+      const packagesPath = join2(cwd, value, "packages");
+      if (!existsSync2(packagesPath)) {
+        return `Could not find packages at ${packagesPath}`;
+      }
+      return true;
+    }
+  });
+  const packages = await checkbox({
+    message: "Select packages to link:",
+    choices: AVAILABLE_PACKAGES.map((pkg) => ({
+      value: pkg,
+      name: `@josui/${pkg}`,
+      checked: true
+    }))
+  });
+  if (packages.length === 0) {
+    console.log("No packages selected. Exiting.");
+    return;
+  }
+  await updateConfig({ josuiPath, linkedPackages: packages }, cwd);
+  await performLink(cwd, josuiPath, packages);
+}
+async function performLink(cwd, josuiPath, packages) {
+  const nodeModulesJosui = join2(cwd, "node_modules", "@josui");
+  if (!existsSync2(nodeModulesJosui)) {
+    await mkdir(nodeModulesJosui, { recursive: true });
+  }
+  console.log("");
+  for (const pkg of packages) {
+    const targetPath = join2(nodeModulesJosui, pkg);
+    const sourcePath = join2(cwd, josuiPath, "packages", pkg);
+    if (existsSync2(targetPath)) {
+      await rm(targetPath, { recursive: true, force: true });
+    }
+    const relativePath = relative(nodeModulesJosui, sourcePath);
+    await symlink(relativePath, targetPath);
+    console.log(`  Linked @josui/${pkg} -> ${relativePath}`);
+  }
+  console.log(`
+\u2713 Linked ${packages.length} package(s)`);
+  console.log("\nConfig saved to .josui.json");
+  const addedGitignore = await ensureGitignore(cwd);
+  if (addedGitignore) {
+    console.log("Added josui entries to .gitignore");
+  }
+}
+
+// src/commands/link-skills.ts
+import { input as input2, select as select2, checkbox as checkbox2 } from "@inquirer/prompts";
+import { existsSync as existsSync3 } from "fs";
+import { readdir, rm as rm2, symlink as symlink2, mkdir as mkdir2, lstat } from "fs/promises";
+import { join as join3, relative as relative2 } from "path";
+async function linkSkills() {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (config?.linkedSkills?.length) {
+    const action = await select2({
+      message: "Found existing skill links. What would you like to do?",
+      choices: [
+        { value: "relink", name: "Re-link existing skills" },
+        { value: "modify", name: "Add or remove skills" },
+        { value: "fresh", name: "Start fresh" }
+      ]
+    });
+    if (action === "relink") {
+      await performSkillLink(cwd, config.linkedSkills);
+      return;
+    }
+    if (action === "modify") {
+      console.log("Starting fresh configuration...\n");
+    }
+  }
+  const sourceType = await select2({
+    message: "Where are the skills you want to link?",
+    choices: [
+      { value: "josui", name: "From josui monorepo" },
+      { value: "package", name: "From an npm package with skills" },
+      { value: "custom", name: "Custom path" }
+    ]
+  });
+  let sourcePath;
+  if (sourceType === "josui") {
+    const defaultPath = config?.josuiPath || "../josui";
+    sourcePath = await input2({
+      message: "Where is your josui monorepo?",
+      default: defaultPath,
+      validate: (value) => {
+        const packagesPath = join3(cwd, value, "packages");
+        if (!existsSync3(packagesPath)) {
+          return `Could not find packages at ${packagesPath}`;
+        }
+        return true;
+      }
+    });
+    const skillSources = await findSkillsInJosui(cwd, sourcePath);
+    if (skillSources.length === 0) {
+      console.log("No packages with skills found in josui.");
+      return;
+    }
+    const allSkills = [];
+    for (const source of skillSources) {
+      for (const skill of source.skills) {
+        allSkills.push({
+          value: `${source.path}:${skill}`,
+          name: `${skill} (from ${source.path})`,
+          source: source.path
+        });
+      }
+    }
+    const selectedSkills = await checkbox2({
+      message: "Select skills to link:",
+      choices: allSkills.map((s) => ({
+        value: s.value,
+        name: s.name,
+        checked: true
+      }))
+    });
+    if (selectedSkills.length === 0) {
+      console.log("No skills selected. Exiting.");
+      return;
+    }
+    const linkedSkills = [];
+    for (const selected of selectedSkills) {
+      const [sourcePkg, skillName] = selected.split(":");
+      const existing = linkedSkills.find((s) => s.source === sourcePkg);
+      if (existing) {
+        existing.skills.push(skillName);
+      } else {
+        linkedSkills.push({ source: sourcePkg, skills: [skillName] });
+      }
+    }
+    await updateConfig({ josuiPath: sourcePath, linkedSkills }, cwd);
+    await performSkillLink(cwd, linkedSkills, sourcePath);
+  } else {
+    sourcePath = await input2({
+      message: "Enter the path to the skills directory:",
+      validate: (value) => {
+        if (!existsSync3(join3(cwd, value))) {
+          return `Path does not exist: ${value}`;
+        }
+        return true;
+      }
+    });
+    const skills = await findSkillsInDir(join3(cwd, sourcePath));
+    if (skills.length === 0) {
+      console.log("No skills found at that path.");
+      return;
+    }
+    const selectedSkills = await checkbox2({
+      message: "Select skills to link:",
+      choices: skills.map((s) => ({
+        value: s,
+        name: s,
+        checked: true
+      }))
+    });
+    if (selectedSkills.length === 0) {
+      console.log("No skills selected. Exiting.");
+      return;
+    }
+    const linkedSkills = [{ source: sourcePath, skills: selectedSkills }];
+    await updateConfig({ linkedSkills }, cwd);
+    await performSkillLink(cwd, linkedSkills);
+  }
+}
+async function findSkillsInJosui(cwd, josuiPath) {
+  const packagesDir = join3(cwd, josuiPath, "packages");
+  const entries = await readdir(packagesDir, { withFileTypes: true });
+  const sources = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillsDir = join3(packagesDir, entry.name, "skills");
+    if (!existsSync3(skillsDir)) continue;
+    const skills = await findSkillsInDir(skillsDir);
+    if (skills.length > 0) {
+      sources.push({ path: entry.name, skills });
+    }
+  }
+  return sources;
+}
+async function findSkillsInDir(dir) {
+  if (!existsSync3(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function performSkillLink(cwd, linkedSkills, josuiPath) {
+  const targetDir = join3(cwd, ".claude", "skills");
+  if (!existsSync3(targetDir)) {
+    await mkdir2(targetDir, { recursive: true });
+  }
+  const existing = await readdir(targetDir, { withFileTypes: true });
+  for (const entry of existing) {
+    if (entry.name.startsWith("josui-linked-")) {
+      const entryPath = join3(targetDir, entry.name);
+      const stat = await lstat(entryPath);
+      if (stat.isSymbolicLink()) {
+        await rm2(entryPath);
+      }
+    }
+  }
+  console.log("");
+  let linked = 0;
+  for (const source of linkedSkills) {
+    for (const skill of source.skills) {
+      let sourcePath;
+      if (josuiPath) {
+        sourcePath = join3(cwd, josuiPath, "packages", source.source, "skills", skill);
+      } else {
+        sourcePath = join3(cwd, source.source, skill);
+      }
+      const destName = `josui-linked-${source.source}-${skill}`;
+      const destPath = join3(targetDir, destName);
+      const relativePath = relative2(targetDir, sourcePath);
+      await symlink2(relativePath, destPath);
+      console.log(`  ${destName}/ -> ${relativePath}`);
+      linked++;
+    }
+  }
+  console.log(`
+\u2713 Linked ${linked} skill(s) to .claude/skills/`);
+  console.log("\nConfig saved to .josui.json");
+  const addedGitignore = await ensureGitignore(cwd);
+  if (addedGitignore) {
+    console.log("Added josui entries to .gitignore");
+  }
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+async function main() {
+  console.log("\n  josui cli\n");
+  const command = args[0];
+  const subcommand = args[1];
+  if (command === "link") {
+    if (subcommand === "packages") {
+      await linkPackages();
+      return;
+    }
+    if (subcommand === "skills") {
+      await linkSkills();
+      return;
+    }
+    const linkType = await select3({
+      message: "What would you like to link?",
+      choices: [
+        { value: "packages", name: "Packages - Link @josui/* packages for local development" },
+        { value: "skills", name: "Skills - Link Claude Code skills from josui" }
+      ]
+    });
+    if (linkType === "packages") {
+      await linkPackages();
+    } else {
+      await linkSkills();
+    }
+    return;
+  }
+  const action = await select3({
+    message: "What would you like to do?",
+    choices: [{ value: "link", name: "Link packages or skills for local development" }]
+  });
+  if (action === "link") {
+    const linkType = await select3({
+      message: "What would you like to link?",
+      choices: [
+        { value: "packages", name: "Packages - Link @josui/* packages for local development" },
+        { value: "skills", name: "Skills - Link Claude Code skills from josui" }
+      ]
+    });
+    if (linkType === "packages") {
+      await linkPackages();
+    } else {
+      await linkSkills();
+    }
+  }
+}
+main().catch((err) => {
+  if (err.name === "ExitPromptError") {
+    console.log("\nCancelled.");
+    process.exit(0);
+  }
+  console.error("Error:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@josui/cli",
+  "version": "0.1.1",
+  "description": "CLI tools for josui",
+  "type": "module",
+  "bin": {
+    "josui": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "@josui/typescript-config": "0.1.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "lint": "eslint src",
+    "typecheck": "tsc --noEmit"
+  }
+}