sdtk-design-kit 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdtk-design-kit",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Local-first MVP design planner and reviewer for SDTK workspaces.",
   "bin": {
     "sdtk-design": "bin/sdtk-design.js"

package/src/commands/init.js

@@ -7,41 +7,67 @@ const { ValidationError } = require("../lib/errors");
 const {
   assertProjectLocalPath,
   describeDesignPaths,
+  isPathInsideOrEqual,
   resolveProjectPath,
 } = require("../lib/design-paths");
+const {
+  VALID_RUNTIMES,
+  VALID_SCOPES,
+  defaultScope,
+  resolveSkillsDir,
+} = require("../lib/runtime-skills");
 
 const INIT_FLAG_DEFS = {
   help: { type: "boolean" },
   "project-path": { type: "string" },
   force: { type: "boolean" },
   "no-state": { type: "boolean" },
+  runtime: { type: "string" },
+  "runtime-scope": { type: "string" },
+  global: { type: "boolean" },
 };
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
 const DESIGN_PROTOTYPE_SKILL_SOURCE = path.join(PACKAGE_ROOT, "skills", "design-prototype");
-const DESIGN_PROTOTYPE_SKILL_TARGETS = [
-  path.join(".claude", "skills", "design-prototype"),
-  path.join(".agents", "skills", "design-prototype"),
-];
 
 function toPosix(value) {
   return String(value || "").replace(/\\/g, "/");
 }
 
+// Report a target either project-relative (when inside the project) or as an
+// absolute posix path (e.g. for user/global skills under the home directory).
+function reportPath(targetPath, projectPath) {
+  if (isPathInsideOrEqual(targetPath, projectPath)) {
+    return toPosix(path.relative(projectPath, targetPath));
+  }
+  return toPosix(targetPath);
+}
+
 function cmdInitHelp() {
   console.log(`SDTK-DESIGN Init
 
 Usage:
-  sdtk-design init [--project-path <path>] [--force] [--no-state]
+  sdtk-design init [--runtime <claude|codex>] [--runtime-scope <project|user>]
+                   [--global] [--project-path <path>] [--force] [--no-state]
 
 Example:
   sdtk-design init
+  sdtk-design init --runtime codex
+  sdtk-design init --runtime claude --global
+
+Runtime:
+  --runtime claude            Install the design-prototype skill under .claude/skills (default).
+  --runtime codex             Install it under .codex/skills (launch Codex with CODEX_HOME).
+  --runtime-scope project     Project-local skills dir (default for claude).
+  --runtime-scope user        User/global skills dir (default for codex).
+  --global                    Shorthand for --runtime-scope user (~/.claude or ~/.codex).
 
 Creates:
   docs/design/
   docs/design/wireframes/
   docs/design/reviews/
   docs/design/README.md
+  <runtime skills dir>/design-prototype/   (e.g. .claude/skills or .codex/skills)
   .sdtk/design/manifest.json unless --no-state is used
 
 Safety:
@@ -139,41 +165,70 @@ function listSkillFiles(sourceDir) {
   return results.sort();
 }
 
-function installDesignPrototypeSkill(projectPath, force, result) {
+// Install the bundled design-prototype skill into a single runtime skills dir
+// (.claude/skills or .codex/skills, per the resolved runtime/scope). For a
+// project-local target the path is guarded inside the project root; for a
+// user/global target (home directory) traversal is guarded against the skills
+// target dir instead, since the destination is intentionally outside the project.
+function installDesignPrototypeSkill(skillsDir, projectPath, force, result) {
   if (!fs.existsSync(DESIGN_PROTOTYPE_SKILL_SOURCE) || !fs.statSync(DESIGN_PROTOTYPE_SKILL_SOURCE).isDirectory()) {
     throw new ValidationError(`Bundled design-prototype skill is missing: ${DESIGN_PROTOTYPE_SKILL_SOURCE}. No project files were changed.`);
   }
 
-  for (const relativeTargetDir of DESIGN_PROTOTYPE_SKILL_TARGETS) {
-    const targetDir = path.join(projectPath, relativeTargetDir);
+  const targetDir = path.join(skillsDir, "design-prototype");
+  if (isPathInsideOrEqual(targetDir, projectPath)) {
     assertProjectLocalPath(targetDir, projectPath, "skill directory");
-    fs.mkdirSync(targetDir, { recursive: true });
-    result.created.push(toPosix(relativeTargetDir) + "/");
-
-    for (const sourceFile of listSkillFiles(DESIGN_PROTOTYPE_SKILL_SOURCE)) {
-      const relativeFile = path.relative(DESIGN_PROTOTYPE_SKILL_SOURCE, sourceFile);
-      const targetFile = path.join(targetDir, relativeFile);
-      assertProjectLocalPath(targetFile, projectPath, "skill file");
-      if (fs.existsSync(targetFile) && !force) {
-        result.skipped.push(toPosix(path.relative(projectPath, targetFile)));
-        continue;
-      }
-      fs.mkdirSync(path.dirname(targetFile), { recursive: true });
-      fs.copyFileSync(sourceFile, targetFile);
-      result.created.push(toPosix(path.relative(projectPath, targetFile)));
+  }
+  fs.mkdirSync(targetDir, { recursive: true });
+  result.created.push(reportPath(targetDir, projectPath) + "/");
+
+  for (const sourceFile of listSkillFiles(DESIGN_PROTOTYPE_SKILL_SOURCE)) {
+    const relativeFile = path.relative(DESIGN_PROTOTYPE_SKILL_SOURCE, sourceFile);
+    const targetFile = path.join(targetDir, relativeFile);
+    if (!isPathInsideOrEqual(targetFile, targetDir)) {
+      throw new ValidationError(`Refusing to write skill file outside its target directory: ${targetFile}`);
+    }
+    if (fs.existsSync(targetFile) && !force) {
+      result.skipped.push(reportPath(targetFile, projectPath));
+      continue;
     }
+    fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+    fs.copyFileSync(sourceFile, targetFile);
+    result.created.push(reportPath(targetFile, projectPath));
+  }
+}
+
+function resolveRuntimeAndScope({ runtime, runtimeScope, global: globalFlag }) {
+  const resolvedRuntime = runtime || "claude";
+  if (!VALID_RUNTIMES.includes(resolvedRuntime)) {
+    throw new ValidationError(`--runtime must be one of: ${VALID_RUNTIMES.join(", ")}. Got: ${resolvedRuntime}.`);
+  }
+  const resolvedScope = globalFlag ? "user" : (runtimeScope || defaultScope(resolvedRuntime));
+  if (!VALID_SCOPES.includes(resolvedScope)) {
+    throw new ValidationError(`--runtime-scope must be one of: ${VALID_SCOPES.join(", ")}. Got: ${resolvedScope}.`);
   }
+  return { runtime: resolvedRuntime, scope: resolvedScope };
 }
 
-function runDesignInit({ projectPath, force = false, state = true }) {
+function runDesignInit({ projectPath, force = false, state = true, runtime, runtimeScope, global: globalFlag }) {
   const resolvedProjectPath = resolveProjectPath(projectPath || process.cwd());
   if (!fs.existsSync(resolvedProjectPath) || !fs.statSync(resolvedProjectPath).isDirectory()) {
     throw new ValidationError(`--project-path is not a valid directory: ${resolvedProjectPath}. No project files were changed.`);
   }
 
+  const { runtime: resolvedRuntime, scope: resolvedScope } = resolveRuntimeAndScope({
+    runtime,
+    runtimeScope,
+    global: globalFlag,
+  });
+  const skillsDir = resolveSkillsDir(resolvedRuntime, resolvedScope, resolvedProjectPath);
+
   const paths = describeDesignPaths(resolvedProjectPath);
   const result = {
     projectPath: resolvedProjectPath,
+    runtime: resolvedRuntime,
+    scope: resolvedScope,
+    skillsDir,
     created: [],
     skipped: [],
     stateEnabled: Boolean(state),
@@ -183,7 +238,7 @@ function runDesignInit({ projectPath, force = false, state = true }) {
   ensureDirectory(paths.wireframesPath, resolvedProjectPath, result);
   ensureDirectory(paths.reviewsPath, resolvedProjectPath, result);
   writeManagedFile(paths.designReadmePath, designReadmeContent(), resolvedProjectPath, force, result);
-  installDesignPrototypeSkill(resolvedProjectPath, force, result);
+  installDesignPrototypeSkill(skillsDir, resolvedProjectPath, force, result);
 
   if (state) {
     ensureDirectory(paths.designStatePath, resolvedProjectPath, result);
@@ -201,9 +256,14 @@ function cmdInit(args) {
     projectPath: flags["project-path"],
     force: Boolean(flags.force),
     state: !flags["no-state"],
+    runtime: flags.runtime,
+    runtimeScope: flags["runtime-scope"],
+    global: Boolean(flags.global),
   });
 
   console.log(`[design] Initialized SDTK-DESIGN workspace: ${result.projectPath}`);
+  console.log(`[design] Runtime: ${result.runtime} (scope: ${result.scope})`);
+  console.log(`[design] Skill:   ${path.join(result.skillsDir, "design-prototype")}`);
   console.log(`[design] Created: ${result.created.length}`);
   console.log(`[design] Skipped: ${result.skipped.length}`);
   console.log(`[design] State: ${result.stateEnabled ? ".sdtk/design enabled" : "disabled by --no-state"}`);

package/src/lib/runtime-skills.js

@@ -0,0 +1,46 @@
+"use strict";
+
+// Runtime/scope → skills directory resolver for SDTK-DESIGN.
+//
+// Mirrors the convention used by the runtime-aware kits (sdtk-spec/ops/code,
+// see their src/lib/scope.js): claude installs skills under `.claude/skills`,
+// codex under `.codex/skills` (honoring CODEX_HOME for the user/global scope).
+// Each kit is an independent npm package, so this small resolver is duplicated
+// rather than imported across package boundaries.
+
+const path = require("path");
+const os = require("os");
+
+const VALID_RUNTIMES = ["claude", "codex"];
+const VALID_SCOPES = ["project", "user"];
+
+// Claude defaults to project-local; Codex defaults to user/global.
+function defaultScope(runtime) {
+  return runtime === "claude" ? "project" : "user";
+}
+
+function resolveCodexHome(scope, projectPath) {
+  if (scope === "project") {
+    return path.join(projectPath || process.cwd(), ".codex");
+  }
+  return process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+}
+
+// Absolute skills directory for the given runtime/scope/project root.
+function resolveSkillsDir(runtime, scope, projectPath) {
+  if (runtime === "claude") {
+    if (scope === "user") {
+      return path.join(os.homedir(), ".claude", "skills");
+    }
+    return path.join(projectPath || process.cwd(), ".claude", "skills");
+  }
+  return path.join(resolveCodexHome(scope, projectPath), "skills");
+}
+
+module.exports = {
+  VALID_RUNTIMES,
+  VALID_SCOPES,
+  defaultScope,
+  resolveCodexHome,
+  resolveSkillsDir,
+};