lagora-cli 1.1.0

package/dist/scripts/install-skill.js

@@ -0,0 +1,199 @@
+// scripts/install-skill.ts
+import { access, copyFile, mkdir, readdir, rm, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var SKILL_NAMES = ["legato-agora-cli", "legato-site-feedback"];
+var USAGE = "Usage: lagora skill install [--target auto|all|codex|claude] [--dest skills-dir]";
+async function installSkill(input) {
+  const args = parseArgs(input.argv);
+  for (const skillName of SKILL_NAMES) {
+    await assertSkillSource(path.join(input.packageRoot, "skills", skillName));
+  }
+  const targets = args.dest ? customTargets(path.resolve(input.cwd, args.dest)) : await platformTargets(args.target, input);
+  if (targets.length === 0) {
+    throw new SkillInstallError("No supported agent platform was detected. Use --target codex|claude or --dest <skills-dir>.");
+  }
+  for (const target of targets) {
+    const source = path.join(input.packageRoot, "skills", target.skillName);
+    await copySkill(source, target.destination, target.includeOpenAiMetadata);
+  }
+  return { installed: targets };
+}
+function parseArgs(argv) {
+  const command = argv[0];
+  if (command !== "install") {
+    throw new SkillInstallError(USAGE);
+  }
+  let target = "auto";
+  let dest;
+  for (let index = 1; index < argv.length; index += 1) {
+    const token = argv[index];
+    const value = argv[index + 1];
+    if (token === "--target") {
+      if (!value || value.startsWith("--")) throw new SkillInstallError("--target requires a value");
+      target = parseTarget(value);
+      index += 1;
+      continue;
+    }
+    if (token === "--dest") {
+      if (!value || value.startsWith("--")) throw new SkillInstallError("--dest requires a value");
+      dest = value;
+      index += 1;
+      continue;
+    }
+    if (token === "-h" || token === "--help") {
+      throw new SkillInstallError(USAGE);
+    }
+    throw new SkillInstallError(`Unknown argument: ${token}`);
+  }
+  return { target, dest };
+}
+function parseTarget(value) {
+  switch (value) {
+    case "auto":
+    case "all":
+    case "codex":
+    case "claude":
+      return value;
+    default:
+      throw new SkillInstallError(`Unsupported target: ${value}`);
+  }
+}
+async function platformTargets(target, input) {
+  const targets = [];
+  const wantsCodex = target === "auto" || target === "all" || target === "codex";
+  const wantsClaude = target === "auto" || target === "all" || target === "claude";
+  if (wantsCodex) {
+    const codexRoot = await codexSkillsRoot(input, target === "codex");
+    if (codexRoot) targets.push(...SKILL_NAMES.map((skillName) => platformTarget("codex", codexRoot, skillName)));
+  }
+  if (wantsClaude) {
+    const roots = await claudeSkillsRoots(input, target === "claude");
+    for (const root of roots) targets.push(...SKILL_NAMES.map((skillName) => platformTarget("claude", root, skillName)));
+  }
+  return uniqueTargets(targets);
+}
+async function codexSkillsRoot(input, explicit) {
+  const envRoot = input.env.CODEX_HOME?.trim();
+  if (envRoot) return path.join(envRoot, "skills");
+  const homeRoot = path.join(input.home, ".codex");
+  if (await exists(homeRoot)) return path.join(homeRoot, "skills");
+  if (await commandExists("codex", input.env)) return path.join(homeRoot, "skills");
+  return explicit ? path.join(homeRoot, "skills") : void 0;
+}
+async function claudeSkillsRoots(input, explicit) {
+  const roots = [];
+  const projectRoot = path.join(input.cwd, ".claude");
+  const homeRoot = path.join(input.home, ".claude");
+  if (await exists(projectRoot)) roots.push(path.join(projectRoot, "skills"));
+  if (await exists(homeRoot)) roots.push(path.join(homeRoot, "skills"));
+  if (roots.length === 0 && await commandExists("claude", input.env)) roots.push(path.join(homeRoot, "skills"));
+  if (roots.length === 0 && explicit) roots.push(path.join(projectRoot, "skills"));
+  return roots;
+}
+function platformTarget(platform, skillsRoot, skillName) {
+  return {
+    platform,
+    skillName,
+    skillsRoot,
+    destination: path.join(skillsRoot, skillName),
+    includeOpenAiMetadata: platform === "codex"
+  };
+}
+function customTarget(skillsRoot, skillName) {
+  return {
+    platform: "custom",
+    skillName,
+    skillsRoot,
+    destination: path.join(skillsRoot, skillName),
+    includeOpenAiMetadata: true
+  };
+}
+function customTargets(skillsRoot) {
+  return SKILL_NAMES.map((skillName) => customTarget(skillsRoot, skillName));
+}
+function uniqueTargets(targets) {
+  const seen = /* @__PURE__ */ new Set();
+  return targets.filter((target) => {
+    if (seen.has(target.destination)) return false;
+    seen.add(target.destination);
+    return true;
+  });
+}
+async function copySkill(source, destination, includeOpenAiMetadata) {
+  await rm(destination, { recursive: true, force: true });
+  await mkdir(destination, { recursive: true });
+  const entries = await readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!includeOpenAiMetadata && entry.name === "agents") continue;
+    const sourcePath = path.join(source, entry.name);
+    const destinationPath = path.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      await copySkill(sourcePath, destinationPath, includeOpenAiMetadata);
+      continue;
+    }
+    if (entry.isFile()) {
+      await copyFile(sourcePath, destinationPath);
+    }
+  }
+}
+async function assertSkillSource(source) {
+  const info = await stat(source).catch((error) => {
+    if (error instanceof Error) throw new SkillInstallError(`Skill source is missing: ${source}`);
+    throw error;
+  });
+  if (!info.isDirectory()) throw new SkillInstallError(`Skill source is not a directory: ${source}`);
+}
+async function exists(targetPath) {
+  try {
+    await access(targetPath, constants.F_OK);
+    return true;
+  } catch (error) {
+    if (error instanceof Error) return false;
+    throw error;
+  }
+}
+async function commandExists(command, env) {
+  const searchPath = env.PATH ?? process.env.PATH ?? "";
+  const directories = searchPath.split(path.delimiter).filter((item) => item.length > 0);
+  for (const directory of directories) {
+    if (await exists(path.join(directory, command))) return true;
+  }
+  return false;
+}
+var SkillInstallError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SkillInstallError";
+  }
+};
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes("-h") || argv.includes("--help")) {
+    console.log(USAGE);
+    return;
+  }
+  const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+  const result = await installSkill({
+    argv,
+    cwd: process.cwd(),
+    env: process.env,
+    home: homedir(),
+    packageRoot
+  });
+  console.log("Installed Lagora skills to:");
+  for (const target of result.installed) {
+    console.log(`- ${target.skillName}: ${target.destination} (${target.platform})`);
+  }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+}
+export {
+  installSkill
+};

package/dist/scripts/issue-local-client-DZUXZOKY.js

@@ -0,0 +1,22 @@
+import {
+  addBlockerToStore,
+  assignIssueInStore,
+  checkoutIssueFromStore,
+  fetchIssueFromStore,
+  printIssueRecord,
+  saveSuggestionToStore,
+  syncBlockerInStore,
+  updateIssueDescriptionInStore,
+  updateIssueStatusInStore
+} from "./chunk-NCJMUBTG.js";
+export {
+  addBlockerToStore,
+  assignIssueInStore,
+  checkoutIssueFromStore,
+  fetchIssueFromStore,
+  printIssueRecord,
+  saveSuggestionToStore,
+  syncBlockerInStore,
+  updateIssueDescriptionInStore,
+  updateIssueStatusInStore
+};