@plasmickit/cli 0.0.39 → 0.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasmickit/cli",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "description": "Plasmic skill bootstrap and NAS workflow resource manager",
   "license": "MIT",
   "repository": {

package/src/agents.mjs

@@ -0,0 +1,96 @@
+import { access, readdir, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+// Global discovery locations are documented in ai/plasmic/README.md.
+export function agentRegistry(home, env) {
+  const user = (relative) => path.join(home, relative);
+  const config = env.XDG_CONFIG_HOME?.trim() || user(".config");
+  const shared = user(".agents/skills");
+  const claude = env.CLAUDE_CONFIG_DIR?.trim() || user(".claude");
+  const codex = env.CODEX_HOME?.trim() || user(".codex");
+  const dsh = env.DSH_HOME?.trim() || user(".dsh");
+  const dshAgents = env.DSH_AGENTS_HOME?.trim() || user(".agents");
+  return [
+    { id: "codex", name: "Codex", roots: [codex], skills: shared, commands: ["codex"], apps: ["Codex"] },
+    { id: "claude-code", name: "Claude Code (CLI / Desktop Code)", roots: [claude], skills: path.join(claude, "skills"), commands: ["claude"], apps: ["Claude"] },
+    { id: "deepseek-harness", name: "DeepSeek Harness", roots: [dsh], skills: path.join(dshAgents, "skills"), commands: ["dsh"] },
+    { id: "cursor", name: "Cursor", roots: [user(".cursor")], skills: shared, commands: ["cursor", "cursor-agent"], apps: ["Cursor"] },
+    { id: "gemini-cli", name: "Gemini CLI", roots: [user(".gemini/settings.json"), user(".gemini/skills")], skills: shared, commands: ["gemini"] },
+    { id: "opencode", name: "OpenCode", roots: [path.join(config, "opencode")], skills: shared, commands: ["opencode"], apps: ["OpenCode"] },
+    { id: "github-copilot", name: "GitHub Copilot", roots: [user(".copilot")], skills: shared, commands: ["copilot"], apps: ["GitHub Copilot"], extensions: ["github.copilot-", "github.copilot-chat-"] },
+    { id: "antigravity", name: "Antigravity", roots: [user(".gemini/config"), user(".gemini/antigravity")], skills: user(".gemini/config/skills"), apps: ["Antigravity", "Antigravity IDE"] },
+    { id: "antigravity-cli", name: "Antigravity CLI", roots: [user(".gemini/antigravity-cli")], skills: user(".gemini/antigravity-cli/skills"), commands: ["agy"] },
+    { id: "windsurf", name: "Windsurf", roots: [user(".codeium/windsurf")], skills: user(".codeium/windsurf/skills"), commands: ["windsurf"], apps: ["Windsurf"] },
+    { id: "cline", name: "Cline", roots: [user(".cline")], skills: shared, commands: ["cline"], extensions: ["saoudrizwan.claude-dev-"] },
+    { id: "roo", name: "Roo Code", roots: [user(".roo")], skills: user(".roo/skills"), extensions: ["rooveterinaryinc.roo-cline-"] },
+    { id: "continue", name: "Continue", roots: [user(".continue")], skills: user(".continue/skills"), commands: ["cn"], extensions: ["continue.continue-"] },
+    { id: "kilo", name: "Kilo Code", roots: [user(".kilo")], skills: user(".kilo/skills"), commands: ["kilo"], extensions: ["kilocode.kilo-code-"] },
+    { id: "kiro", name: "Kiro", roots: [user(".kiro")], skills: user(".kiro/skills"), commands: ["kiro-cli", "kiro"], apps: ["Kiro"] },
+    { id: "trae", name: "Trae", roots: [user(".trae")], skills: user(".trae/skills"), apps: ["Trae"] },
+    { id: "trae-cn", name: "Trae CN", roots: [user(".trae-cn")], skills: user(".trae-cn/skills"), apps: ["Trae CN"] },
+    { id: "qwen-code", name: "Qwen Code", roots: [user(".qwen")], skills: user(".qwen/skills"), commands: ["qwen"] },
+    { id: "amp", name: "Amp", roots: [path.join(config, "amp")], skills: path.join(config, "agents/skills"), commands: ["amp"] },
+    { id: "goose", name: "Goose", roots: [path.join(config, "goose")], skills: path.join(config, "goose/skills"), commands: ["goose"], apps: ["Goose"] },
+    { id: "droid", name: "Droid", roots: [user(".factory")], skills: shared, commands: ["droid"] },
+    { id: "pi", name: "Pi", roots: [user(".pi/agent")], skills: shared, commands: ["pi"] },
+    { id: "openclaw", name: "OpenClaw", roots: [user(".openclaw")], skills: user(".openclaw/skills"), commands: ["openclaw"] },
+    { id: "zcode", name: "ZCode", roots: [user(".zcode")], skills: user(".zcode/skills"), apps: ["ZCode"] },
+    { id: "zed", name: "Zed", roots: [path.join(config, "zed"), ...(env.APPDATA ? [path.join(env.APPDATA, "Zed")] : [])], skills: shared, commands: ["zed"], apps: ["Zed"] },
+  ];
+}
+
+async function exists(filename) {
+  try { await stat(filename); return true; }
+  catch (error) { if (["ENOENT", "ENOTDIR"].includes(error.code)) return false; throw error; }
+}
+
+async function commandPath(command, env, platform) {
+  const extensions = platform === "win32" ? ["", ...(env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";")] : [""];
+  for (const directory of (env.PATH || env.Path || "").split(platform === "win32" ? ";" : ":").filter(Boolean)) {
+    for (const extension of extensions) {
+      const filename = path.join(directory.replace(/^"|"$/g, ""), command + extension);
+      try {
+        if (!(await stat(filename)).isFile()) continue;
+        await access(filename, platform === "win32" ? constants.F_OK : constants.X_OK);
+        return filename;
+      } catch (error) {
+        if (!["ENOENT", "ENOTDIR", "EACCES"].includes(error.code)) throw error;
+      }
+    }
+  }
+}
+
+function applicationPaths(name, home, env, platform) {
+  if (platform === "darwin") return ["/Applications", path.join(home, "Applications")].map((root) => path.join(root, name + ".app"));
+  if (platform === "win32") return [env.APPDATA, env.ProgramData].filter(Boolean).map((root) => path.join(root, "Microsoft/Windows/Start Menu/Programs", name + ".lnk"));
+  const basename = name.toLowerCase().replaceAll(" ", "-") + ".desktop";
+  return [env.XDG_DATA_HOME || path.join(home, ".local/share"), ...(env.XDG_DATA_DIRS || "/usr/local/share:/usr/share").split(":")].map((root) => path.join(root, "applications", basename));
+}
+
+export async function detectInstalledAgents({ home = homedir(), env = process.env, platform = process.platform } = {}) {
+  const extensionRoots = [".vscode", ".vscode-insiders", ".cursor", ".windsurf"].map((root) => path.join(home, root, "extensions"));
+  const extensions = [];
+  for (const root of extensionRoots) {
+    try { extensions.push(...(await readdir(root, { withFileTypes: true })).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => path.join(root, entry.name))); }
+    catch (error) { if (!["ENOENT", "ENOTDIR"].includes(error.code)) throw error; }
+  }
+  const installed = [];
+  for (const agent of agentRegistry(home, env)) {
+    const evidence = [];
+    for (const root of agent.roots) if (await exists(root)) evidence.push({ kind: "config", path: root });
+    for (const command of agent.commands || []) {
+      const filename = await commandPath(command, env, platform);
+      if (filename) evidence.push({ kind: "cli", path: filename });
+    }
+    for (const name of agent.apps || []) {
+      for (const filename of applicationPaths(name, home, env, platform)) if (await exists(filename)) evidence.push({ kind: "app", path: filename });
+    }
+    for (const filename of extensions) {
+      if (agent.extensions?.some((prefix) => path.basename(filename).toLowerCase().startsWith(prefix))) evidence.push({ kind: "extension", path: filename });
+    }
+    if (evidence.length) installed.push({ id: agent.id, name: agent.name, skillsRoot: path.resolve(agent.skills), evidence });
+  }
+  return installed;
+}

package/src/index.mjs

@@ -8,7 +8,7 @@ import { installSkill } from "./skill.mjs";
 import { CLI_VERSION } from "./protocol.mjs";
 
 const usage = `plasmickit commands:
-  skill install --target SKILLS_ROOT
+  skill install [--dry-run]
   version check [--feed HTTPS_URL]
   references check|update|path [--feed HTTPS_URL] [--home CACHE_ROOT]
   context resolve --mode prototype|codegen [--feed HTTPS_URL] [--home CACHE_ROOT]
@@ -16,7 +16,7 @@ const usage = `plasmickit commands:
 `;
 export async function main(argv) {
   const { values, positionals } = parseArgs({ args: argv, allowPositionals: true, options: {
-    target: { type: "string" }, mode: { type: "string" }, feed: { type: "string" }, home: { type: "string" },
+    "dry-run": { type: "boolean" }, mode: { type: "string" }, feed: { type: "string" }, home: { type: "string" },
     help: { type: "boolean" }, version: { type: "boolean" },
   } });
   if (values.version) { process.stdout.write(CLI_VERSION + "\n"); return; }
@@ -24,7 +24,7 @@ export async function main(argv) {
   const [command, action] = positionals;
   if (positionals.length !== 2) throw new Error("Expected a command and action; use --help");
   let output;
-  if (command === "skill" && action === "install") output = await installSkill(values.target);
+  if (command === "skill" && action === "install") output = await installSkill({ dryRun: values["dry-run"] });
   else if (command === "version" && action === "check") output = await checkCliVersion(values);
   else if (command === "references" && action === "check") output = await checkReferences(values);
   else if (command === "references" && action === "update") {
@@ -35,6 +35,7 @@ export async function main(argv) {
   else if (command === "context" && action === "resolve") output = await resolveContext(values.mode, values);
   else throw new Error(`Unknown command: ${command} ${action}`);
   process.stdout.write(JSON.stringify({ ok: true, ...output }, null, 2) + "\n");
+  if (output.ok === false) process.exitCode = 1;
 }
 if (process.argv[1] && realpathSync(path.resolve(process.argv[1])) === fileURLToPath(import.meta.url)) {
   main(process.argv.slice(2)).catch((error) => {

package/src/skill.mjs

@@ -1,11 +1,49 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import path from "node:path";
+import { detectInstalledAgents } from "./agents.mjs";
 
-export async function installSkill(targetRoot) {
-  if (!targetRoot) throw new Error("skill install requires --target SKILLS_ROOT");
-  const target = path.resolve(targetRoot, "plasmic");
+async function physicalPath(filename) {
+  try { return await realpath(filename); }
+  catch (error) {
+    if (!["ENOENT", "ENOTDIR"].includes(error.code)) throw error;
+    const parent = path.dirname(filename);
+    return parent === filename ? filename : path.join(await physicalPath(parent), path.basename(filename));
+  }
+}
+
+export async function installSkill({ dryRun = false, ...options } = {}) {
+  const detected = await detectInstalledAgents(options);
+  if (!detected.length) return { ok: false, mode: "bootstrap", detected, installations: [], error: "No supported local Agent CLI or app detected. Install or initialize a supported client, then rerun skill install." };
   const content = await readFile(new URL("../skill/plasmic/SKILL.md", import.meta.url), "utf8");
-  await mkdir(target, { recursive: true });
-  await writeFile(path.join(target, "SKILL.md"), content);
-  return { target, skillPath: path.join(target, "SKILL.md"), mode: "bootstrap" };
+  const destinations = new Map();
+  const installations = [];
+  for (const agent of detected) {
+    const target = path.join(agent.skillsRoot, "plasmic");
+    let physicalTarget;
+    try { physicalTarget = await physicalPath(target); }
+    catch (error) {
+      installations.push({ agents: [agent.id], target, skillPath: path.join(target, "SKILL.md"), status: "failed", error: error.message }); continue;
+    }
+    const key = (options.platform || process.platform) === "win32" ? physicalTarget.toLowerCase() : physicalTarget;
+    if (destinations.has(key)) destinations.get(key).agents.push(agent.id);
+    else destinations.set(key, { agents: [agent.id], target, skillPath: path.join(target, "SKILL.md") });
+  }
+  for (const destination of destinations.values()) {
+    if (dryRun) { installations.push({ ...destination, status: "planned" }); continue; }
+    try {
+      let previous;
+      try { previous = await readFile(destination.skillPath, "utf8"); }
+      catch (error) { if (error.code !== "ENOENT") throw error; }
+      if (previous === content) { installations.push({ ...destination, status: "unchanged" }); continue; }
+      await mkdir(destination.target, { recursive: true });
+      const temporary = path.join(destination.target, `.SKILL-${randomUUID()}.tmp`);
+      try {
+        await writeFile(temporary, content, { flag: "wx" });
+        await rename(temporary, destination.skillPath);
+      } finally { await rm(temporary, { force: true }); }
+      installations.push({ ...destination, status: "installed" });
+    } catch (error) { installations.push({ ...destination, status: "failed", error: error.message }); }
+  }
+  return { ok: installations.every((result) => result.status !== "failed"), mode: "bootstrap", dryRun, detected, installations };
 }