@anvia/cli 1.1.1 → 1.3.0

package/README.md

@@ -13,3 +13,51 @@ pnpm dlx @anvia/cli add chat
 
 Available items: `chat`, `thread`, `message`, `composer`, `attachment`, `markdown`, and
 `tool-fallback`.
+
+## Updating installed components
+
+`update` compares the Anvia components in your project against the current registry:
+
+```sh
+pnpm dlx @anvia/cli update            # check every item (preview only, writes nothing)
+pnpm dlx @anvia/cli update composer   # check a single item
+pnpm dlx @anvia/cli update --overwrite
+```
+
+Without `--overwrite`, `update` is a preview: it reports each file as `up-to-date`,
+`modified` (the installed copy differs from the registry), or `missing`. Pass `--overwrite`
+to write the registry content over out-of-date and missing files of installed components.
+`update` never installs new items — use `add` for that. Locally edited copies are
+overwritten, so commit or stash your changes first.
+
+## Agent Skills
+
+Scaffold the Anvia Agent Skills — curated, API-verified knowledge for building with
+Anvia (agents, chat, RAG, MCP, pipelines, Studio, evals, channels) — so your coding
+agent writes correct Anvia code:
+
+```sh
+pnpm dlx @anvia/cli skills list                          # show the available skills
+pnpm dlx @anvia/cli skills init                          # copy every skill into ./skills
+pnpm dlx @anvia/cli skills init --claude --agents        # also wire Claude Code and AGENTS.md
+pnpm dlx @anvia/cli skills init --codex --cursor         # --codex is an AGENTS.md alias
+pnpm dlx @anvia/cli skills update                        # compare installed skills (preview only)
+pnpm dlx @anvia/cli skills update --force
+```
+
+`skills init` always writes the canonical skills into `./skills` (override with
+`--dir <path>`) — one folder per skill (`SKILL.md` + `references/` + `scripts/`), with
+the executable bit preserved on skill scripts — and prints the wiring snippet. Generated
+adapters and the snippet always reference the effective directory. The
+target flags add adapters on top:
+
+- `--claude` copies the skills into `.claude/skills/`, where Claude Code loads them natively.
+- `--cursor` writes one on-demand Cursor rule per skill into `.cursor/rules/` that points
+  at the matching `skills/<name>/SKILL.md`.
+- `--agents` (and its alias `--codex`) maintains an `AGENTS.md` section, between
+  `anvia-skills` markers, listing every skill with its description. Existing
+  `AGENTS.md` content outside the markers is never touched.
+
+Skills you have locally edited are left alone unless you pass `--force`. `skills update`
+refreshes installed skills and adapters in place and never reinstalls skills that were
+removed from the project. Both commands accept `--cwd <path>`.

package/dist/chunk-ERCP4EIZ.js

@@ -0,0 +1,607 @@
+// src/registry.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { tmpdir } from "os";
+import { basename, dirname, join } from "path";
+import { fileURLToPath } from "url";
+var registryItemNames = [
+  "chat",
+  "thread",
+  "message",
+  "composer",
+  "attachment",
+  "markdown",
+  "tool-fallback"
+];
+var itemFiles = {
+  attachment: ["attachment.tsx"],
+  chat: [
+    "attachment.tsx",
+    "markdown.tsx",
+    "tool-fallback.tsx",
+    "message.tsx",
+    "composer.tsx",
+    "thread.tsx",
+    "chat.tsx"
+  ],
+  composer: ["attachment.tsx", "composer.tsx"],
+  markdown: ["markdown.tsx"],
+  message: ["attachment.tsx", "markdown.tsx", "tool-fallback.tsx", "message.tsx"],
+  thread: ["attachment.tsx", "markdown.tsx", "tool-fallback.tsx", "message.tsx", "thread.tsx"],
+  "tool-fallback": ["tool-fallback.tsx"]
+};
+var revealCss = {
+  "@keyframes anvia-stream-gradient-settle": {
+    to: {
+      opacity: "1"
+    }
+  },
+  "@layer components": {
+    '.anvia-markdown [data-state="revealing"]': {
+      animation: "anvia-stream-gradient-settle var(--anvia-stream-reveal-duration, 180ms) linear both",
+      opacity: "var(--anvia-stream-reveal-opacity, 1)"
+    },
+    "@media (prefers-reduced-motion: reduce)": {
+      '.anvia-markdown [data-state="revealing"]': {
+        animation: "none",
+        opacity: "1"
+      }
+    }
+  }
+};
+function createRegistryItem(name, options = {}) {
+  const packageVersion = options.packageVersion ?? currentPackageVersion();
+  const registryDirectory = options.registryDirectory ?? bundledRegistryDirectory();
+  const files = itemFiles[name].map((filename) => ({
+    content: readFileSync(join(registryDirectory, filename), "utf8"),
+    path: `registry/anvia/${filename}`,
+    target: `@components/anvia/${filename}`,
+    type: "registry:component"
+  }));
+  const item = {
+    $schema: "https://ui.shadcn.com/schema/registry-item.json",
+    dependencies: [`@anvia/react-ui@${packageVersion}`],
+    description: registryItemDescription(name),
+    files,
+    name,
+    title: `Anvia ${name}`,
+    type: files.length === 1 ? "registry:component" : "registry:block"
+  };
+  if (name === "chat" || name === "markdown" || name === "message" || name === "thread") {
+    item.css = revealCss;
+  }
+  return item;
+}
+function initializeProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const args = ["init", "--cwd", cwd, "--yes", "--no-monorepo", "--base", "radix"];
+  if (options.template !== void 0) {
+    args.push("--template", options.template);
+  }
+  if (options.force === true) {
+    args.push("--force");
+  }
+  runShadcn(args);
+}
+function addRegistryItem(name, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const temporaryDirectory = mkdtempSync(join(tmpdir(), "anvia-registry-"));
+  const itemPath = join(temporaryDirectory, `${name}.json`);
+  try {
+    writeFileSync(itemPath, `${JSON.stringify(createRegistryItem(name), null, 2)}
+`);
+    const args = ["add", itemPath, "--cwd", cwd, "--yes"];
+    if (options.overwrite === true) {
+      args.push("--overwrite");
+    }
+    runShadcn(args);
+  } finally {
+    rmSync(temporaryDirectory, { force: true, recursive: true });
+  }
+}
+function isRegistryItemName(value) {
+  return registryItemNames.includes(value);
+}
+function inspectInstalledItems(options = {}) {
+  const names = options.items ?? registryItemNames;
+  const directory = componentsDirectory(options);
+  const registry = options.registryDirectory ?? bundledRegistryDirectory();
+  return names.map((name) => {
+    const files = itemFiles[name].map((filename) => {
+      const path = join(directory, "anvia", filename);
+      let status = "missing";
+      if (existsSync(path)) {
+        const installed = readFileSync(path, "utf8");
+        status = installed === registryFileContent(registry, filename) ? "up-to-date" : "modified";
+      }
+      return { filename, path, status };
+    });
+    return {
+      name,
+      installed: files.some((file) => file.status !== "missing"),
+      complete: files.every((file) => file.status !== "missing"),
+      files
+    };
+  });
+}
+function updateInstalledItems(options = {}) {
+  const registry = options.registryDirectory ?? bundledRegistryDirectory();
+  const report = inspectInstalledItems(options);
+  const updated = [];
+  if (options.overwrite === true) {
+    const actionable = /* @__PURE__ */ new Map();
+    for (const item of report) {
+      if (!item.installed) {
+        continue;
+      }
+      for (const file of item.files) {
+        if (file.status === "up-to-date" || actionable.has(file.path)) {
+          continue;
+        }
+        actionable.set(file.path, registryFileContent(registry, file.filename));
+      }
+    }
+    for (const [path, content] of actionable) {
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, content);
+      updated.push(path);
+    }
+  }
+  return { report, updated };
+}
+function closestRegistryItemName(value) {
+  let best;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const name of registryItemNames) {
+    const distance = levenshteinDistance(value, name);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = name;
+    }
+  }
+  return bestDistance <= 2 ? best : void 0;
+}
+function componentsDirectory(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const manifestPath = join(cwd, "components.json");
+  let manifest;
+  try {
+    manifest = JSON.parse(stripJsonComments(readFileSync(manifestPath, "utf8")));
+  } catch {
+    throw new Error(`Missing or unreadable components.json in ${cwd}. Run \`anvia init\` first.`);
+  }
+  const alias = manifest.aliases?.components ?? "@/components";
+  return resolveAliasDirectory(cwd, alias);
+}
+function resolveAliasDirectory(cwd, alias) {
+  for (const configName of ["tsconfig.json", "jsconfig.json"]) {
+    let config;
+    try {
+      config = JSON.parse(stripJsonComments(readFileSync(join(cwd, configName), "utf8")));
+    } catch {
+      continue;
+    }
+    const paths = config.compilerOptions?.paths;
+    if (paths === void 0) {
+      continue;
+    }
+    const target = resolveAliasTarget(alias, paths);
+    if (target === void 0) {
+      continue;
+    }
+    return join(cwd, config.compilerOptions?.baseUrl ?? ".", target);
+  }
+  throw new Error(
+    `Cannot resolve the components alias "${alias}" from tsconfig.json or jsconfig.json in ${cwd}.`
+  );
+}
+function resolveAliasTarget(alias, paths) {
+  for (const [key, targets] of Object.entries(paths)) {
+    const target = targets[0];
+    if (target === void 0) {
+      continue;
+    }
+    if (key.endsWith("/*")) {
+      const prefix = key.slice(0, -2);
+      if (alias === prefix) {
+        return target.replace(/\/\*$/, "");
+      }
+      if (alias.startsWith(`${prefix}/`)) {
+        return join(target.replace(/\/\*$/, ""), alias.slice(prefix.length + 1));
+      }
+    } else if (key === alias) {
+      return target;
+    }
+  }
+  return void 0;
+}
+function stripJsonComments(source) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const character = source[index];
+    if (inString) {
+      result += character;
+      if (escaped) {
+        escaped = false;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === "/" && source[index + 1] === "/") {
+      while (index < source.length && source[index] !== "\n") {
+        index += 1;
+      }
+      continue;
+    }
+    result += character;
+  }
+  return result;
+}
+function registryFileContent(registryDirectory, filename) {
+  return readFileSync(join(registryDirectory, filename), "utf8");
+}
+function levenshteinDistance(left, right) {
+  const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= left.length; i += 1) {
+    let diagonal = previous[0];
+    previous[0] = i;
+    for (let j = 1; j <= right.length; j += 1) {
+      const above = previous[j];
+      previous[j] = Math.min(
+        above + 1,
+        previous[j - 1] + 1,
+        diagonal + (left[i - 1] === right[j - 1] ? 0 : 1)
+      );
+      diagonal = above;
+    }
+  }
+  return previous[right.length];
+}
+function runShadcn(args) {
+  const require2 = createRequire(import.meta.url);
+  const shadcnEntry = require2.resolve("shadcn");
+  const result = spawnSync(process.execPath, [shadcnEntry, ...args], {
+    encoding: "utf8",
+    stdio: "inherit"
+  });
+  if (result.error !== void 0) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`shadcn ${args[0] ?? "command"} failed with exit code ${result.status}.`);
+  }
+}
+function bundledRegistryDirectory() {
+  return fileURLToPath(new URL("./registry/", import.meta.url));
+}
+function currentPackageVersion() {
+  const manifestPath = fileURLToPath(new URL("../package.json", import.meta.url));
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  if (typeof manifest.version !== "string") {
+    throw new Error(`Missing package version in ${basename(manifestPath)}.`);
+  }
+  return manifest.version;
+}
+function registryItemDescription(name) {
+  if (name === "chat") {
+    return "A complete editable Anvia chat interface.";
+  }
+  return `Editable Anvia ${name} UI.`;
+}
+
+// src/skills/discovery.ts
+import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function bundledSkillsDirectory() {
+  return fileURLToPath2(new URL("./skills/", import.meta.url));
+}
+function skillNames(options = {}) {
+  const directory = options.skillsDirectory ?? bundledSkillsDirectory();
+  return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+function skillsTargetDirectory(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  return join2(cwd, options.dir ?? "skills");
+}
+function collectSkillFiles(root) {
+  const files = [];
+  const visit = (directory, prefix) => {
+    const entries = readdirSync(directory, { withFileTypes: true }).sort(
+      (left, right) => left.name.localeCompare(right.name)
+    );
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        visit(join2(directory, entry.name), `${prefix}${entry.name}/`);
+      } else if (entry.isFile()) {
+        files.push(`${prefix}${entry.name}`);
+      }
+    }
+  };
+  visit(root, "");
+  return files;
+}
+function skillDescription(skillsDirectory, name) {
+  const source = readFileSync2(join2(skillsDirectory, name, "SKILL.md"), "utf8");
+  return (/^description:\s*(.+)$/m.exec(source)?.[1] ?? "").trim();
+}
+
+// src/skills/write.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+
+// src/skills/adapters/agents-doc.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var agentsSectionStart = "<!-- anvia-skills:start -->";
+var agentsSectionEnd = "<!-- anvia-skills:end -->";
+function syncAgentsDoc(options) {
+  const section = agentsSkillsSection(options.skillsDirectory, options.canonicalDir);
+  if (!existsSync2(options.agentsPath)) {
+    mkdirSync2(dirname2(options.agentsPath), { recursive: true });
+    writeFileSync2(options.agentsPath, `# AGENTS.md
+
+${section}
+`);
+    return { created: [options.agentsPath], updated: [], skipped: 0 };
+  }
+  const existing = readFileSync3(options.agentsPath, "utf8");
+  const startIndex = existing.indexOf(agentsSectionStart);
+  const endIndex = existing.indexOf(agentsSectionEnd);
+  let next;
+  if (startIndex === -1 || endIndex === -1) {
+    next = `${existing.replace(/\n+$/, "")}
+
+${section}
+`;
+  } else {
+    next = existing.slice(0, startIndex) + section + existing.slice(endIndex + agentsSectionEnd.length);
+  }
+  if (next === existing) {
+    return { created: [], updated: [], skipped: 0 };
+  }
+  writeFileSync2(options.agentsPath, next);
+  return { created: [], updated: [options.agentsPath], skipped: 0 };
+}
+function agentsSkillsSection(skillsDirectory, canonicalDir) {
+  const lines = skillNames({ skillsDirectory }).map(
+    (name) => `- \`${canonicalDir}/${name}/SKILL.md\` \u2014 ${skillDescription(skillsDirectory, name)}`
+  );
+  return [
+    agentsSectionStart,
+    "## Anvia Agent Skills",
+    "",
+    `This project keeps Anvia Agent Skills in \`${canonicalDir}/\`. When a task matches a skill, read`,
+    "its `SKILL.md` first and follow it, including the `references/` files and `scripts/`",
+    "it points to. Run skill scripts with `sh` when they help verify the work.",
+    "",
+    ...lines,
+    agentsSectionEnd
+  ].join("\n");
+}
+
+// src/skills/adapters/claude.ts
+import { join as join4 } from "path";
+
+// src/skills/adapters/skill-tree.ts
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+function syncSkillTree(options) {
+  const created = [];
+  const updated = [];
+  let skipped = 0;
+  for (const name of skillNames({ skillsDirectory: options.skillsDirectory })) {
+    const sourceRoot = join3(options.skillsDirectory, name);
+    const targetRoot = join3(options.targetRoot, name);
+    const sourceFiles = collectSkillFiles(sourceRoot);
+    if (options.mode === "update" && !isSkillInstalled(targetRoot, sourceFiles)) {
+      continue;
+    }
+    for (const relativePath of sourceFiles) {
+      const outcome = syncOneFile(sourceRoot, targetRoot, relativePath, options);
+      if (outcome === "created") {
+        created.push(join3(targetRoot, relativePath));
+      } else if (outcome === "updated") {
+        updated.push(join3(targetRoot, relativePath));
+      } else if (outcome === "skipped") {
+        skipped += 1;
+      }
+    }
+  }
+  return { created, updated, skipped };
+}
+function isSkillInstalled(targetRoot, sourceFiles) {
+  return sourceFiles.some((file) => existsSync3(join3(targetRoot, file)));
+}
+function syncOneFile(sourceRoot, targetRoot, relativePath, options) {
+  const sourcePath = join3(sourceRoot, relativePath);
+  const targetPath = join3(targetRoot, relativePath);
+  const content = readFileSync4(sourcePath, "utf8");
+  if (!existsSync3(targetPath)) {
+    if (options.mode === "update" && !options.force) {
+      return "skipped";
+    }
+    mkdirSync3(dirname3(targetPath), { recursive: true });
+    writeFileSync3(targetPath, content);
+    chmodSync(targetPath, statSync(sourcePath).mode & 511);
+    return "created";
+  }
+  if (readFileSync4(targetPath, "utf8") === content) {
+    return "unchanged";
+  }
+  if (!options.force) {
+    return "skipped";
+  }
+  writeFileSync3(targetPath, content);
+  chmodSync(targetPath, statSync(sourcePath).mode & 511);
+  return "updated";
+}
+
+// src/skills/adapters/claude.ts
+function syncClaudeSkills(options) {
+  return syncSkillTree({
+    skillsDirectory: options.skillsDirectory,
+    targetRoot: join4(options.cwd, ".claude", "skills"),
+    force: options.force,
+    mode: options.mode
+  });
+}
+
+// src/skills/adapters/cursor-rules.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4, join as join5 } from "path";
+function syncCursorRules(options) {
+  const created = [];
+  const updated = [];
+  let skipped = 0;
+  for (const name of skillNames({ skillsDirectory: options.skillsDirectory })) {
+    const targetPath = join5(options.rulesDirectory, `${name}.mdc`);
+    const content = cursorRuleContent(options.skillsDirectory, name, options.canonicalDir);
+    if (!existsSync4(targetPath)) {
+      if (options.mode === "update" && !options.force) {
+        continue;
+      }
+      mkdirSync4(dirname4(targetPath), { recursive: true });
+      writeFileSync4(targetPath, content);
+      created.push(targetPath);
+      continue;
+    }
+    if (readFileSync5(targetPath, "utf8") === content) {
+      continue;
+    }
+    if (!options.force) {
+      skipped += 1;
+      continue;
+    }
+    writeFileSync4(targetPath, content);
+    updated.push(targetPath);
+  }
+  return { created, updated, skipped };
+}
+function cursorRuleContent(skillsDirectory, name, canonicalDir) {
+  const description = skillDescription(skillsDirectory, name).replace(/"/g, '\\"');
+  return [
+    "---",
+    `description: "${description}"`,
+    "alwaysApply: false",
+    "---",
+    "",
+    `When a task matches this skill, read \`${canonicalDir}/${name}/SKILL.md\` at the project root and`,
+    "follow it, including the `references/` files and `scripts/` it points to. Run skill",
+    "scripts with `sh` when they help verify the work.",
+    ""
+  ].join("\n");
+}
+
+// src/skills/write.ts
+function inspectInstalledSkills(options = {}) {
+  const skillsDirectory = options.skillsDirectory ?? bundledSkillsDirectory();
+  const target = skillsTargetDirectory(options);
+  return skillNames({ skillsDirectory }).map((name) => {
+    const files = collectSkillFiles(join6(skillsDirectory, name)).map((relativePath) => {
+      const path = join6(target, name, relativePath);
+      let status = "missing";
+      if (existsSync5(path)) {
+        const installed = readFileSync6(path, "utf8");
+        const source = readFileSync6(join6(skillsDirectory, name, relativePath), "utf8");
+        status = installed === source ? "up-to-date" : "modified";
+      }
+      return { relativePath, path, status };
+    });
+    return {
+      name,
+      installed: files.some((file) => file.status !== "missing"),
+      complete: files.every((file) => file.status !== "missing"),
+      files
+    };
+  });
+}
+function initSkills(options = {}) {
+  return writeSkills({ ...options, mode: "init" });
+}
+function updateSkills(options = {}) {
+  return writeSkills({ ...options, mode: "update" });
+}
+function writeSkills(options) {
+  const skillsDirectory = options.skillsDirectory ?? bundledSkillsDirectory();
+  const cwd = options.cwd ?? process.cwd();
+  const force = options.force === true;
+  const canonicalDir = options.dir ?? "skills";
+  const targets = new Set(options.targets ?? ["anvia"]);
+  targets.add("anvia");
+  const results = [];
+  const anvia = syncSkillTree({
+    skillsDirectory,
+    targetRoot: skillsTargetDirectory(options),
+    force,
+    mode: options.mode
+  });
+  results.push({ target: "anvia", ...anvia });
+  if (targets.has("claude")) {
+    const claude = syncClaudeSkills({ cwd, skillsDirectory, force, mode: options.mode });
+    results.push({ target: "claude", ...claude });
+  }
+  if (targets.has("cursor")) {
+    const cursor = syncCursorRules({
+      skillsDirectory,
+      rulesDirectory: join6(cwd, ".cursor", "rules"),
+      canonicalDir,
+      force,
+      mode: options.mode
+    });
+    results.push({ target: "cursor", ...cursor });
+  }
+  if (targets.has("agents") || targets.has("codex")) {
+    const doc = syncAgentsDoc({
+      agentsPath: join6(cwd, "AGENTS.md"),
+      skillsDirectory,
+      canonicalDir
+    });
+    const target = targets.has("agents") ? "agents" : "codex";
+    results.push({ target, ...doc });
+  }
+  return {
+    report: inspectInstalledSkills(options),
+    created: anvia.created,
+    updated: anvia.updated,
+    targets: results
+  };
+}
+
+// src/skills/types.ts
+var skillsTargetNames = ["anvia", "claude", "codex", "cursor", "agents"];
+function isSkillsTarget(value) {
+  return skillsTargetNames.includes(value);
+}
+
+export {
+  registryItemNames,
+  createRegistryItem,
+  initializeProject,
+  addRegistryItem,
+  isRegistryItemName,
+  inspectInstalledItems,
+  updateInstalledItems,
+  closestRegistryItemName,
+  bundledSkillsDirectory,
+  skillNames,
+  skillsTargetDirectory,
+  collectSkillFiles,
+  inspectInstalledSkills,
+  initSkills,
+  updateSkills,
+  skillsTargetNames,
+  isSkillsTarget
+};
+//# sourceMappingURL=chunk-ERCP4EIZ.js.map