@callmeradical/augy 0.1.0

package/dist/install-FPAGHWX2.js

@@ -0,0 +1,192 @@
+import {
+  filterableMultiselect
+} from "./chunk-UJX6VJ3S.js";
+import {
+  resolveSkillFromTaps
+} from "./chunk-YXCEZ3EY.js";
+import {
+  AGENTS,
+  agentSkillPath
+} from "./chunk-R2TJ3UDO.js";
+import {
+  discoverSkills,
+  downloadSkill,
+  parseGitHubUrl
+} from "./chunk-EU54UQ4C.js";
+import {
+  createSkillRecord,
+  getSkill,
+  readRegistry,
+  shortSha,
+  writeRegistry
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/install.ts
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  multiselect,
+  outro,
+  select,
+  spinner,
+  text
+} from "@clack/prompts";
+import chalk from "chalk";
+import { mkdir, rm } from "fs/promises";
+async function installCommand(urlArg, opts = {}) {
+  intro(chalk.bold("augy") + chalk.dim(" \u2014 skill installer"));
+  const registry = await readRegistry();
+  const rawUrl = urlArg ?? await promptUrl();
+  if (isCancel(rawUrl) || !rawUrl) return bail();
+  const isBare = !String(rawUrl).includes("/") && !String(rawUrl).startsWith("http");
+  let discovered;
+  let resolvedSource;
+  let resolvedTap;
+  if (isBare) {
+    const s = spinner();
+    s.start(`Searching taps for "${rawUrl}"\u2026`);
+    const tapResult = await resolveSkillFromTaps(registry, String(rawUrl));
+    if (!tapResult) {
+      s.stop(chalk.yellow(`"${rawUrl}" not found in any tap`));
+      cancel(
+        `No taps contain a skill named "${rawUrl}".
+Try: augy install owner/repo/path   or add a tap with: augy tap add owner/repo`
+      );
+      process.exit(1);
+    }
+    let chosen;
+    if (Array.isArray(tapResult)) {
+      s.stop(`Found "${rawUrl}" in ${tapResult.length} taps \u2014 please choose`);
+      const pick = await select({
+        message: "Which tap should this skill be installed from?",
+        options: tapResult.map((ts) => ({
+          value: ts,
+          label: ts.tapKey,
+          hint: chalk.dim("@" + shortSha(ts.sha))
+        }))
+      });
+      if (isCancel(pick)) return bail();
+      chosen = pick;
+    } else {
+      chosen = tapResult;
+      s.stop(`Found in tap ${chalk.cyan(chosen.tapKey)}`);
+    }
+    discovered = [chosen];
+    resolvedSource = `${chosen.tapKey}/${chosen.repoPath}`;
+    resolvedTap = chosen.tapKey;
+  } else {
+    const s = spinner();
+    s.start("Resolving skills from GitHub\u2026");
+    try {
+      const coords = parseGitHubUrl(String(rawUrl));
+      discovered = await discoverSkills(coords);
+      resolvedSource = String(rawUrl);
+    } catch (err) {
+      s.stop(chalk.red("Failed to resolve skills"));
+      cancel(String(err));
+      process.exit(1);
+    }
+    if (!discovered.length) {
+      s.stop(chalk.yellow("No skills found at that location"));
+      cancel("Make sure the path contains a SKILL.md file or subdirectories that do.");
+      process.exit(1);
+    }
+    s.stop(`Found ${chalk.green(String(discovered.length))} skill(s)`);
+  }
+  const selectedSkills = await promptSkillSelection(discovered);
+  if (isCancel(selectedSkills) || !selectedSkills.length) return bail();
+  const preselectedAgents = opts.agent ?? [];
+  const selectedAgents = preselectedAgents.length > 0 ? AGENTS.filter((a) => preselectedAgents.includes(a.id)) : await promptAgentSelection();
+  if (isCancel(selectedAgents) || !selectedAgents.length) return bail();
+  const lines = selectedSkills.map(
+    (sk) => `  ${chalk.cyan(sk.name)} ${chalk.dim("@" + shortSha(sk.sha))} \u2192 ${selectedAgents.map((a) => chalk.bold(a.name)).join(", ")}`
+  );
+  console.log("\n" + lines.join("\n") + "\n");
+  const ok = await confirm({ message: "Install the above skill(s)?" });
+  if (isCancel(ok) || !ok) return bail();
+  for (const skill of selectedSkills) {
+    const s2 = spinner();
+    s2.start(`Installing ${chalk.cyan(skill.name)}\u2026`);
+    try {
+      const existing = getSkill(registry, skill.name);
+      if (existing) {
+        s2.message(`${chalk.cyan(skill.name)} already installed \u2014 updating record`);
+      }
+      const agentPaths = {};
+      for (const agent of selectedAgents) {
+        agentPaths[agent.id] = agentSkillPath(agent, skill.name);
+      }
+      for (const agent of selectedAgents) {
+        const dest = agentPaths[agent.id];
+        await mkdir(dest, { recursive: true });
+        await rm(dest, { recursive: true, force: true });
+        await downloadSkill(skill.gigetSource, dest);
+      }
+      const record = createSkillRecord({
+        name: skill.name,
+        source: resolvedSource,
+        gigetSource: skill.gigetSource,
+        sha: skill.sha,
+        agentIds: selectedAgents.map((a) => a.id),
+        agentPaths,
+        tap: resolvedTap
+      });
+      if (existing) {
+        record.installedAt = existing.installedAt;
+        record.pinned = existing.pinned;
+        record.history = existing.history;
+      }
+      registry.skills[skill.name] = record;
+      s2.stop(`${chalk.green("\u2713")} ${chalk.cyan(skill.name)} ${chalk.dim("@" + shortSha(skill.sha))}`);
+    } catch (err) {
+      s2.stop(`${chalk.red("\u2717")} ${chalk.cyan(skill.name)} \u2014 ${String(err)}`);
+    }
+  }
+  await writeRegistry(registry);
+  outro(
+    chalk.green("Done!") + chalk.dim(` Registry saved \u2192 ~/.augy/registry.json`)
+  );
+}
+async function promptUrl() {
+  return text({
+    message: "GitHub URL or owner/repo[/path]",
+    placeholder: "https://github.com/owner/repo  or  owner/repo/skills/my-skill",
+    validate: (v) => v.trim() ? void 0 : "Please enter a URL or repo path"
+  });
+}
+async function promptSkillSelection(skills) {
+  const installed = new Set(Object.keys((await readRegistry()).skills));
+  return filterableMultiselect({
+    message: "Select skills to install",
+    options: skills.map((s) => {
+      const isInstalled = installed.has(s.name);
+      return {
+        value: s,
+        label: s.name,
+        hint: chalk.dim("@" + shortSha(s.sha)) + (isInstalled ? chalk.yellow("  already installed") : "  " + chalk.dim(s.repoPath)),
+        selected: !isInstalled
+        // pre-select everything not yet installed
+      };
+    })
+  });
+}
+async function promptAgentSelection() {
+  return multiselect({
+    message: "Install for which agents?",
+    options: AGENTS.map((a) => ({
+      value: a,
+      label: a.name,
+      hint: chalk.dim(a.skillsPath)
+    })),
+    required: true
+  });
+}
+function bail() {
+  cancel("Installation cancelled");
+  process.exit(0);
+}
+export {
+  installCommand
+};

package/dist/list-UJX2MYXK.js

@@ -0,0 +1,70 @@
+import {
+  AGENTS
+} from "./chunk-R2TJ3UDO.js";
+import {
+  listSkills,
+  readRegistry
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/list.ts
+import chalk from "chalk";
+async function listCommand(opts = {}) {
+  const registry = await readRegistry();
+  const skills = listSkills(registry);
+  if (opts.json) {
+    console.log(JSON.stringify(registry, null, 2));
+    return;
+  }
+  if (!skills.length) {
+    console.log(chalk.dim("No skills installed. Run `augy install` to get started."));
+    return;
+  }
+  console.log(
+    `
+${chalk.bold("Installed skills")}  ${chalk.dim(`(${skills.length} total)`)}
+`
+  );
+  for (const skill of skills) {
+    printSkill(skill);
+  }
+  console.log();
+}
+function printSkill(skill) {
+  const pinTag = skill.pinned ? chalk.yellow(" [pinned]") : "";
+  const historyTag = skill.history.length > 0 ? chalk.dim(` (${skill.history.length} previous version${skill.history.length === 1 ? "" : "s"})`) : "";
+  const noSource = !skill.source || skill.sha === "unversioned";
+  const shaDisplay = noSource ? chalk.yellow("untracked") : chalk.green("@" + skill.shortSha);
+  const sourceNote = noSource ? chalk.yellow("  \u26A0 no source \u2014 run `augy set-source " + skill.name + " <url>` to enable updates") : "";
+  console.log(
+    `  ${chalk.cyan.bold(skill.name)}${pinTag}  ${shaDisplay}${historyTag}${sourceNote}`
+  );
+  if (skill.source) {
+    console.log(`  ${chalk.dim("source:")}  ${skill.source}`);
+  } else {
+    console.log(`  ${chalk.dim("source:")}  ${chalk.dim("unknown")}`);
+  }
+  const agentEntries = Object.entries(skill.agents);
+  if (agentEntries.length) {
+    const agentLabels = agentEntries.map(([id, install]) => {
+      const agent = AGENTS.find((a) => a.id === id);
+      const name = agent?.name ?? id;
+      const status = install.active ? chalk.green(name) : chalk.dim(`${name} (inactive)`);
+      return status;
+    });
+    console.log(`  ${chalk.dim("agents:")}   ${agentLabels.join(chalk.dim(", "))}`);
+  }
+  const updated = new Date(skill.updatedAt).toLocaleDateString();
+  console.log(`  ${chalk.dim("updated:")}  ${updated}`);
+  if (skill.history.length > 0) {
+    const prev = skill.history.slice(-3).reverse();
+    const lines = prev.map(
+      (v) => `    ${chalk.dim(v.sha.slice(0, 7))}  ${chalk.dim(new Date(v.installedAt).toLocaleDateString())}`
+    );
+    console.log(`  ${chalk.dim("history:")}`);
+    lines.forEach((l) => console.log(l));
+  }
+  console.log();
+}
+export {
+  listCommand
+};

package/dist/registry-QVCNZXBZ.js

@@ -0,0 +1,38 @@
+import {
+  addTap,
+  augyHome,
+  createSkillRecord,
+  getSkill,
+  getTap,
+  listSkills,
+  listTaps,
+  readRegistry,
+  registryPath,
+  removeSkill,
+  removeTap,
+  shortSha,
+  tapKey,
+  upsertSkill,
+  versionArchivePath,
+  versionsDir,
+  writeRegistry
+} from "./chunk-ZW6ZKHTF.js";
+export {
+  addTap,
+  augyHome,
+  createSkillRecord,
+  getSkill,
+  getTap,
+  listSkills,
+  listTaps,
+  readRegistry,
+  registryPath,
+  removeSkill,
+  removeTap,
+  shortSha,
+  tapKey,
+  upsertSkill,
+  versionArchivePath,
+  versionsDir,
+  writeRegistry
+};

package/dist/rollback-WAZV5HNG.js

@@ -0,0 +1,105 @@
+import {
+  archiveExists,
+  restoreVersion
+} from "./chunk-PX2LVUHV.js";
+import {
+  agentById,
+  agentSkillPath
+} from "./chunk-R2TJ3UDO.js";
+import {
+  getSkill,
+  readRegistry,
+  shortSha,
+  writeRegistry
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/rollback.ts
+import { cancel, intro, isCancel, outro, select, spinner } from "@clack/prompts";
+import chalk from "chalk";
+async function rollbackCommand(nameArg, shaArg) {
+  intro(chalk.bold("augy") + chalk.dim(" \u2014 rollback"));
+  const registry = await readRegistry();
+  const skill = getSkill(registry, nameArg);
+  if (!skill) {
+    cancel(`Skill "${nameArg}" not found in registry. Run \`augy list\` to see installed skills.`);
+    process.exit(1);
+  }
+  if (!skill.history.length) {
+    cancel(`No previous versions for "${nameArg}". Cannot roll back.`);
+    process.exit(0);
+  }
+  let targetSha;
+  if (shaArg) {
+    const match = skill.history.find((v) => v.sha.startsWith(shaArg));
+    if (!match) {
+      cancel(
+        `Version "${shaArg}" not found in history for "${nameArg}".
+Available: ${skill.history.map((v) => v.sha.slice(0, 7)).join(", ")}`
+      );
+      process.exit(1);
+    }
+    targetSha = match.sha;
+  } else {
+    const versions = [...skill.history].reverse();
+    const chosen = await select({
+      message: `Roll back "${nameArg}" to which version?`,
+      options: versions.map((v) => {
+        const exists = archiveExists(nameArg, v.sha);
+        return {
+          value: v.sha,
+          label: shortSha(v.sha),
+          hint: new Date(v.installedAt).toLocaleDateString() + (exists ? "" : chalk.red("  [archive missing]"))
+        };
+      })
+    });
+    if (isCancel(chosen)) {
+      cancel("Rollback cancelled");
+      process.exit(0);
+    }
+    targetSha = chosen;
+  }
+  if (!archiveExists(nameArg, targetSha)) {
+    cancel(
+      `Archive not found for "${nameArg}" @ ${shortSha(targetSha)}.
+The snapshot may have been pruned.`
+    );
+    process.exit(1);
+  }
+  const destPaths = Object.entries(skill.agents).filter(([, install]) => install.active).map(([agentId]) => {
+    const agent = agentById(agentId);
+    return agent ? agentSkillPath(agent, nameArg) : null;
+  }).filter((p) => p !== null);
+  const s = spinner();
+  s.start(`Restoring ${chalk.cyan(nameArg)} to ${chalk.yellow(shortSha(targetSha))}\u2026`);
+  try {
+    const currentDest = destPaths[0];
+    if (currentDest) {
+      const { archiveVersion } = await import("./versions-OMI6OFJC.js");
+      await archiveVersion(currentDest, nameArg, skill.sha);
+    }
+    await restoreVersion(nameArg, targetSha, destPaths);
+    const restoredEntry = skill.history.find((v) => v.sha === targetSha);
+    const displacedEntry = {
+      sha: skill.sha,
+      installedAt: skill.updatedAt,
+      archivePath: `${process.env["HOME"] ?? "~"}/.augy/versions/${nameArg}/${skill.sha}`
+    };
+    skill.history = skill.history.filter((v) => v.sha !== targetSha);
+    skill.history.push(displacedEntry);
+    skill.sha = targetSha;
+    skill.shortSha = shortSha(targetSha);
+    skill.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    registry.skills[nameArg] = skill;
+    await writeRegistry(registry);
+    s.stop(
+      `${chalk.green("\u2713")} Rolled back ${chalk.cyan(nameArg)} to ` + chalk.yellow(shortSha(targetSha))
+    );
+    outro(chalk.dim(`Previous version archived for future rollback.`));
+  } catch (err) {
+    s.stop(`${chalk.red("\u2717")} Rollback failed \u2014 ${String(err)}`);
+    process.exit(1);
+  }
+}
+export {
+  rollbackCommand
+};