@callmeradical/augy 0.1.0

package/dist/scan-DKN7YBT5.js

@@ -0,0 +1,328 @@
+import {
+  detectProvenance,
+  injectSourceIntoSkillMd
+} from "./chunk-KCQY4IDO.js";
+import {
+  filterableMultiselect
+} from "./chunk-UJX6VJ3S.js";
+import {
+  resolveSkillFromTaps
+} from "./chunk-YXCEZ3EY.js";
+import {
+  AGENTS
+} from "./chunk-R2TJ3UDO.js";
+import {
+  discoverSkills,
+  parseGitHubUrl
+} from "./chunk-EU54UQ4C.js";
+import {
+  createSkillRecord,
+  getSkill,
+  listSkills,
+  readRegistry,
+  shortSha,
+  writeRegistry
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/scan.ts
+import { readdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  outro,
+  spinner,
+  text
+} from "@clack/prompts";
+import chalk from "chalk";
+import { homedir } from "os";
+async function scanCommand() {
+  intro(chalk.bold("augy") + chalk.dim(" \u2014 scan"));
+  const registry = await readRegistry();
+  const s = spinner();
+  s.start("Scanning agent skill directories\u2026");
+  const onDisk = await findAllOnDiskSkills();
+  s.stop(`Scanned ${AGENTS.length} agent(s)`);
+  const untracked = [];
+  for (const [name, agents] of onDisk) {
+    if (!getSkill(registry, name)) {
+      untracked.push({ name, agents });
+    }
+  }
+  const tracked = listSkills(registry);
+  if (!untracked.length) {
+    outro(chalk.green("All installed skills are already tracked by augy."));
+    return;
+  }
+  const s2 = spinner();
+  s2.start(`Detecting provenance for ${untracked.length} skill(s)\u2026`);
+  await Promise.allSettled(
+    untracked.map(async (sk) => {
+      const firstPath = sk.agents[0]?.path;
+      if (!firstPath) return;
+      const result = await detectProvenance(firstPath, sk.name);
+      if (result) {
+        sk.provenance = result;
+      } else {
+        const tapMatch = await tryResolveTapSource(registry, sk.name);
+        if (tapMatch) {
+          sk.provenance = {
+            source: `${tapMatch.tapKey}/${tapMatch.repoPath}`,
+            gigetSource: tapMatch.gigetSource,
+            sha: tapMatch.sha,
+            confidence: "tap",
+            description: `tap: ${tapMatch.tapKey}`
+          };
+        }
+      }
+      if (!sk.provenance) {
+        sk.description = await readSkillDescription(firstPath);
+      }
+    })
+  );
+  const detected = untracked.filter((sk) => sk.provenance);
+  const unknown = untracked.filter((sk) => !sk.provenance);
+  s2.stop(
+    detected.length === untracked.length ? chalk.green(`Provenance found for all ${detected.length} skill(s)`) : detected.length > 0 ? `Provenance found for ${chalk.green(String(detected.length))} of ${untracked.length} \xB7 ` + chalk.yellow(`${unknown.length} unknown`) : chalk.yellow(`No provenance found for any of the ${untracked.length} skill(s)`)
+  );
+  const managedNote = tracked.length ? chalk.dim(`  ${tracked.length} already managed by augy`) : "";
+  console.log(
+    `
+  ${chalk.bold(String(untracked.length))} untracked skill(s) found${managedNote}
+`
+  );
+  if (detected.length) {
+    console.log(
+      chalk.bold("  Provenance detected") + chalk.dim(` (${detected.length})`) + "  " + chalk.dim("\u2500".repeat(36))
+    );
+    for (const sk of detected) {
+      printDetected(sk);
+    }
+  }
+  if (unknown.length) {
+    console.log(
+      chalk.bold("  No provenance found") + chalk.dim(` (${unknown.length})`) + "  " + chalk.dim("\u2500".repeat(35))
+    );
+    for (const sk of unknown) {
+      printUnknown(sk);
+    }
+  }
+  const doImport = await confirm({ message: "Import untracked skills into augy?" });
+  if (isCancel(doImport) || !doImport) {
+    cancel("No changes made.");
+    process.exit(0);
+  }
+  const toImport = untracked.length === 1 ? untracked : await selectSkillsToImport(untracked);
+  if (isCancel(toImport) || !toImport.length) {
+    cancel("Cancelled");
+    process.exit(0);
+  }
+  let importedCount = 0;
+  for (const sk of toImport) {
+    console.log();
+    console.log(`  ${chalk.cyan.bold(sk.name)}`);
+    const detected2 = sk.provenance;
+    let resolvedSource;
+    let resolvedGigetSource;
+    let resolvedSha;
+    let resolvedTap;
+    if (detected2) {
+      const confidenceLabel = {
+        git: chalk.green("git remote"),
+        frontmatter: chalk.cyan("SKILL.md frontmatter"),
+        tap: chalk.cyan("tap match"),
+        unknown: chalk.dim("unknown")
+      };
+      console.log(
+        `  ${chalk.dim("via")}     ${confidenceLabel[detected2.confidence] ?? detected2.confidence}
+  ${chalk.dim("source")}  ${detected2.source}` + (detected2.sha ? `  ${chalk.dim("@" + shortSha(detected2.sha))}` : "")
+      );
+      const useDetected = await confirm({ message: "Use detected source?", initialValue: true });
+      if (isCancel(useDetected)) {
+        cancel("Cancelled");
+        process.exit(0);
+      }
+      if (useDetected) {
+        resolvedSource = detected2.source;
+        resolvedGigetSource = detected2.gigetSource;
+        resolvedSha = detected2.sha;
+        if (detected2.confidence === "tap") {
+          const tm = await tryResolveTapSource(registry, sk.name);
+          resolvedTap = tm?.tapKey;
+        }
+      }
+    }
+    if (!resolvedSource) {
+      if (!detected2) {
+        console.log(`  ${chalk.dim("Locations:")}`);
+        for (const { agent, path } of sk.agents) {
+          console.log(`    ${chalk.bold(agent.name.padEnd(10))}  ${chalk.dim(tildefy(path))}`);
+        }
+        if (sk.description) {
+          console.log(`  ${chalk.dim("Description:")}  ${chalk.dim(sk.description)}`);
+        }
+        console.log();
+      }
+      const sourceInput = await text({
+        message: "GitHub URL or owner/repo[/path]",
+        placeholder: "https://github.com/owner/repo  (leave blank to import without source)",
+        defaultValue: ""
+      });
+      if (isCancel(sourceInput)) {
+        cancel("Cancelled");
+        process.exit(0);
+      }
+      resolvedSource = (sourceInput ?? "").trim();
+    }
+    const s3 = spinner();
+    let sha;
+    let gigetSource;
+    if (resolvedSha && resolvedGigetSource) {
+      sha = resolvedSha;
+      gigetSource = resolvedGigetSource;
+    } else if (!resolvedSource) {
+      sha = "unversioned";
+      gigetSource = "";
+    } else {
+      s3.start(`Fetching SHA for ${chalk.cyan(sk.name)}\u2026`);
+      try {
+        const coords = parseGitHubUrl(resolvedSource);
+        const remote = await discoverSkills(coords);
+        const match = remote.find((r) => r.name === sk.name) ?? remote[0];
+        if (!match) throw new Error("Skill not found at that source");
+        sha = match.sha;
+        gigetSource = match.gigetSource;
+        s3.stop(chalk.dim("@" + shortSha(sha)));
+      } catch (err) {
+        s3.stop(chalk.yellow("Could not fetch SHA \u2014 importing as unversioned"));
+        console.log(chalk.dim(`  ${String(err)}`));
+        sha = "unversioned";
+        gigetSource = resolvedGigetSource ?? `github:${resolvedSource.replace("https://github.com/", "")}`;
+      }
+    }
+    const record = createSkillRecord({
+      name: sk.name,
+      source: resolvedSource,
+      gigetSource,
+      sha,
+      agentIds: sk.agents.map((a) => a.agent.id),
+      agentPaths: Object.fromEntries(sk.agents.map((a) => [a.agent.id, a.path])),
+      tap: resolvedTap
+    });
+    registry.skills[sk.name] = record;
+    importedCount++;
+    await writeRegistry(registry);
+    if (sha !== "unversioned" && resolvedSource) {
+      await injectSourceIntoSkillMd(sk.agents[0].path, resolvedSource).catch(() => void 0);
+    }
+    const sourceTag = !resolvedSource ? chalk.yellow("  (no source \u2014 add one later with `augy set-source`)") : sha !== "unversioned" ? chalk.dim(`  @${shortSha(sha)}`) : chalk.yellow("  (unversioned)");
+    console.log(`  ${chalk.green("\u2713")} ${chalk.cyan(sk.name)} imported${sourceTag}`);
+  }
+  outro(
+    importedCount > 0 ? chalk.green(`${importedCount} skill(s) imported into augy`) : chalk.dim("No skills imported.")
+  );
+}
+function printDetected(sk) {
+  const p = sk.provenance;
+  const confidenceColor = {
+    git: chalk.green,
+    frontmatter: chalk.cyan,
+    tap: chalk.cyan
+  };
+  const color = confidenceColor[p.confidence] ?? chalk.dim;
+  const agents = sk.agents.map((a) => chalk.bold(a.agent.name)).join(", ");
+  console.log(
+    `
+  ${chalk.cyan.bold(sk.name)}  ${chalk.dim("\u2192")}  ${agents}`
+  );
+  console.log(
+    `  ${chalk.dim("source")}  ${p.source}` + (p.sha ? chalk.dim(`  @${shortSha(p.sha)}`) : "") + `  ${color(`[${p.confidence}]`)}`
+  );
+}
+function printUnknown(sk) {
+  console.log(`
+  ${chalk.cyan.bold(sk.name)}  ${chalk.yellow("(no provenance found)")}`);
+  for (const { agent, path } of sk.agents) {
+    console.log(`  ${chalk.dim(agent.name.padEnd(10))}  ${tildefy(path)}`);
+  }
+  if (sk.description) {
+    console.log(`  ${chalk.dim(sk.description)}`);
+  }
+}
+async function selectSkillsToImport(skills) {
+  return filterableMultiselect({
+    message: "Which skills do you want to import?",
+    options: skills.map((sk) => ({
+      value: sk,
+      label: sk.name,
+      hint: sk.provenance ? chalk.green(sk.provenance.confidence) + "  " + chalk.dim(sk.provenance.source) : chalk.yellow("no provenance") + "  " + chalk.dim(tildefy(sk.agents[0]?.path ?? "")),
+      selected: true
+    }))
+  });
+}
+async function findAllOnDiskSkills() {
+  const result = /* @__PURE__ */ new Map();
+  await Promise.all(
+    AGENTS.map(async (agent) => {
+      if (!existsSync(agent.skillsPath)) return;
+      let entries;
+      try {
+        const dirents = await readdir(agent.skillsPath, { withFileTypes: true });
+        entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+      } catch {
+        return;
+      }
+      for (const name of entries) {
+        const skillPath = join(agent.skillsPath, name);
+        if (!existsSync(join(skillPath, agent.skillFile))) continue;
+        if (!result.has(name)) result.set(name, []);
+        result.get(name).push({ agent, path: skillPath });
+      }
+    })
+  );
+  return result;
+}
+async function readSkillDescription(skillPath) {
+  const skillMd = join(skillPath, "SKILL.md");
+  if (!existsSync(skillMd)) return void 0;
+  try {
+    const content = await readFile(skillMd, "utf8");
+    const lines = content.split("\n");
+    let inFrontmatter = false;
+    let pastFrontmatter = false;
+    for (const line of lines) {
+      if (line.trim() === "---") {
+        if (!pastFrontmatter) {
+          inFrontmatter = !inFrontmatter;
+          if (!inFrontmatter) pastFrontmatter = true;
+        }
+        continue;
+      }
+      if (inFrontmatter) continue;
+      if (!line.trim() || line.startsWith("#")) continue;
+      return line.trim().slice(0, 80) + (line.trim().length > 80 ? "\u2026" : "");
+    }
+  } catch {
+  }
+  return void 0;
+}
+function tildefy(p) {
+  const home = homedir();
+  return p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}
+async function tryResolveTapSource(registry, name) {
+  if (!Object.keys(registry.taps).length) return void 0;
+  try {
+    const result = await resolveSkillFromTaps(registry, name);
+    if (!result) return void 0;
+    return Array.isArray(result) ? result[0] : result;
+  } catch {
+    return void 0;
+  }
+}
+export {
+  scanCommand
+};

package/dist/search-2V2U23KC.js

@@ -0,0 +1,78 @@
+import {
+  searchTaps
+} from "./chunk-YXCEZ3EY.js";
+import "./chunk-EU54UQ4C.js";
+import {
+  listSkills,
+  readRegistry,
+  shortSha
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/search.ts
+import { spinner } from "@clack/prompts";
+import chalk from "chalk";
+async function searchCommand(query) {
+  const registry = await readRegistry();
+  const taps = Object.keys(registry.taps);
+  if (!taps.length) {
+    console.log(
+      chalk.dim("No taps registered. Add one first:\n") + `  ${chalk.bold("augy tap add owner/repo")}`
+    );
+    return;
+  }
+  const s = spinner();
+  s.start(
+    query ? `Searching ${taps.length} tap(s) for "${query}"\u2026` : `Fetching skill index from ${taps.length} tap(s)\u2026`
+  );
+  let results;
+  try {
+    results = await searchTaps(registry, query);
+  } catch (err) {
+    s.stop(chalk.red("Search failed"));
+    console.error(String(err));
+    process.exit(1);
+  }
+  const totalMatches = results.reduce((n, r) => n + r.skills.length, 0);
+  s.stop(
+    totalMatches > 0 ? `Found ${chalk.green(String(totalMatches))} skill(s)` : chalk.yellow("No skills found")
+  );
+  if (!totalMatches) {
+    if (query) {
+      console.log(chalk.dim(`
+No skills match "${query}". Try a broader term.`));
+    }
+    return;
+  }
+  const installed = new Map(listSkills(registry).map((s2) => [s2.name, s2]));
+  console.log();
+  for (const result of results) {
+    if (result.skills.length === 0 && !result.error) continue;
+    console.log(chalk.bold(result.tapKey) + chalk.dim(`  (${result.tap.skillsPath || "root"})`));
+    if (result.error) {
+      console.log(`  ${chalk.red("Error:")} ${result.error}`);
+      console.log();
+      continue;
+    }
+    for (const skill of result.skills) {
+      printSkillRow(skill, installed);
+    }
+    console.log();
+  }
+}
+function printSkillRow(skill, installed) {
+  const inst = installed.get(skill.name);
+  let statusBadge;
+  if (!inst) {
+    statusBadge = chalk.dim("not installed");
+  } else if (inst.sha === skill.sha) {
+    statusBadge = chalk.green("\u2713 up to date");
+  } else {
+    statusBadge = chalk.yellow(`\u2191 update available  ${chalk.dim(inst.shortSha + " \u2192 " + shortSha(skill.sha))}`);
+  }
+  console.log(
+    `  ${chalk.cyan.bold(skill.name.padEnd(24))}  ${chalk.dim("@" + shortSha(skill.sha))}  ${statusBadge}`
+  );
+}
+export {
+  searchCommand
+};

package/dist/set-source-TITL27N3.js

@@ -0,0 +1,63 @@
+import {
+  injectSourceIntoSkillMd
+} from "./chunk-KCQY4IDO.js";
+import {
+  buildGigetSource,
+  latestShaForPath,
+  parseGitHubUrl
+} from "./chunk-EU54UQ4C.js";
+import {
+  getSkill,
+  readRegistry,
+  shortSha,
+  writeRegistry
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/set-source.ts
+import { cancel, intro, outro, spinner } from "@clack/prompts";
+import chalk from "chalk";
+async function setSourceCommand(skillName, sourceArg) {
+  intro(chalk.bold("augy") + chalk.dim(" \u2014 set-source"));
+  const registry = await readRegistry();
+  const skill = getSkill(registry, skillName);
+  if (!skill) {
+    cancel(`Skill "${skillName}" not found. Run \`augy list\` to see installed skills.`);
+    process.exit(1);
+  }
+  const s = spinner();
+  s.start(`Resolving ${chalk.cyan(sourceArg)}\u2026`);
+  let sha;
+  let gigetSource;
+  try {
+    const coords = parseGitHubUrl(sourceArg);
+    const { owner, repo, path, ref } = coords;
+    sha = await latestShaForPath(owner, repo, path || ".", ref);
+    gigetSource = buildGigetSource(owner, repo, path, ref);
+    s.stop(
+      `Resolved  ${chalk.dim(`${owner}/${repo}/${path}`)}  ${chalk.green("@" + shortSha(sha))}`
+    );
+  } catch (err) {
+    s.stop(chalk.red("Failed to resolve source"));
+    cancel(String(err));
+    process.exit(1);
+  }
+  skill.source = sourceArg;
+  skill.gigetSource = gigetSource;
+  skill.sha = sha;
+  skill.shortSha = shortSha(sha);
+  skill.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  registry.skills[skillName] = skill;
+  await writeRegistry(registry);
+  for (const [, install] of Object.entries(skill.agents)) {
+    if (install.active) {
+      await injectSourceIntoSkillMd(install.path, sourceArg).catch(() => void 0);
+    }
+  }
+  outro(
+    chalk.green(`${skillName} source set`) + chalk.dim(`  @${shortSha(sha)}`) + `
+  ${chalk.dim("Updates and diffs are now available.")}`
+  );
+}
+export {
+  setSourceCommand
+};

package/dist/tap-3RD3XZ56.js

@@ -0,0 +1,142 @@
+import {
+  parseTapArg,
+  tapSource
+} from "./chunk-YXCEZ3EY.js";
+import {
+  discoverSkills,
+  parseGitHubUrl
+} from "./chunk-EU54UQ4C.js";
+import {
+  addTap,
+  listTaps,
+  readRegistry,
+  removeTap,
+  tapKey,
+  writeRegistry
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/tap.ts
+import { cancel, confirm, intro, isCancel, outro, spinner, text } from "@clack/prompts";
+import chalk from "chalk";
+async function tapAddCommand(repoArg, opts) {
+  intro(chalk.bold("augy tap") + chalk.dim(" \u2014 add"));
+  let parsed;
+  try {
+    parsed = parseTapArg(repoArg);
+  } catch (err) {
+    cancel(String(err));
+    process.exit(1);
+  }
+  const { owner, repo } = parsed;
+  const key = tapKey(owner, repo);
+  const registry = await readRegistry();
+  if (registry.taps[key]) {
+    cancel(`Tap "${key}" is already registered.`);
+    process.exit(0);
+  }
+  let skillsPath = opts.path;
+  if (skillsPath === void 0) {
+    const answer = await text({
+      message: "Path within the repo where skills live (leave blank for repo root)",
+      placeholder: "skills",
+      defaultValue: "skills"
+    });
+    if (isCancel(answer)) {
+      cancel("Cancelled");
+      process.exit(0);
+    }
+    skillsPath = answer.trim();
+  }
+  const s = spinner();
+  s.start(`Verifying ${chalk.cyan(key)}\u2026`);
+  let skillCount = 0;
+  try {
+    const source = tapSource(owner, repo, skillsPath);
+    const coords = parseGitHubUrl(source);
+    const skills = await discoverSkills(coords);
+    skillCount = skills.length;
+    s.stop(`Found ${chalk.green(String(skillCount))} skill(s) in ${chalk.cyan(key)}`);
+  } catch (err) {
+    s.stop(chalk.yellow("Could not verify tap \u2014 will add anyway"));
+    console.log(chalk.dim(`  ${String(err)}`));
+  }
+  const tap = {
+    owner,
+    repo,
+    skillsPath,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...opts.description ? { description: opts.description } : {}
+  };
+  addTap(registry, tap);
+  await writeRegistry(registry);
+  outro(
+    chalk.green(`Tap ${chalk.bold(key)} added`) + chalk.dim(skillCount ? ` (${skillCount} skills available)` : "")
+  );
+}
+async function tapRemoveCommand(repoArg) {
+  intro(chalk.bold("augy tap") + chalk.dim(" \u2014 remove"));
+  let parsed;
+  try {
+    parsed = parseTapArg(repoArg);
+  } catch (err) {
+    cancel(String(err));
+    process.exit(1);
+  }
+  const key = tapKey(parsed.owner, parsed.repo);
+  const registry = await readRegistry();
+  if (!registry.taps[key]) {
+    cancel(`Tap "${key}" is not registered.`);
+    process.exit(1);
+  }
+  const affected = Object.values(registry.skills).filter((sk) => sk.tap === key);
+  if (affected.length) {
+    console.log(
+      chalk.yellow(
+        `  ${affected.length} installed skill(s) came from this tap: ` + affected.map((s) => chalk.cyan(s.name)).join(", ")
+      )
+    );
+    console.log(chalk.dim("  They will remain installed but lose their tap association.\n"));
+  }
+  const ok = await confirm({ message: `Remove tap "${key}"?` });
+  if (isCancel(ok) || !ok) {
+    cancel("Cancelled");
+    process.exit(0);
+  }
+  for (const sk of affected) {
+    delete sk.tap;
+    registry.skills[sk.name] = sk;
+  }
+  removeTap(registry, key);
+  await writeRegistry(registry);
+  outro(chalk.green(`Tap ${chalk.bold(key)} removed`));
+}
+async function tapListCommand() {
+  const registry = await readRegistry();
+  const taps = listTaps(registry);
+  if (!taps.length) {
+    console.log(
+      chalk.dim("No taps registered.\n") + chalk.dim("Add one with: ") + chalk.bold("augy tap add owner/repo")
+    );
+    return;
+  }
+  console.log(`
+${chalk.bold("Registered taps")}  ${chalk.dim(`(${taps.length} total)`)}
+`);
+  for (const tap of taps) {
+    const skillsFrom = Object.values(registry.skills).filter((s) => s.tap === tap.key).length;
+    const pathLabel = tap.skillsPath ? chalk.dim(`/${tap.skillsPath}`) : "";
+    console.log(
+      `  ${chalk.cyan.bold(tap.key)}${pathLabel}` + (tap.description ? `  ${chalk.dim("\u2014")}  ${tap.description}` : "")
+    );
+    console.log(`  ${chalk.dim("added:")}    ${new Date(tap.addedAt).toLocaleDateString()}`);
+    if (skillsFrom > 0) {
+      console.log(`  ${chalk.dim("installed:")} ${skillsFrom} skill(s) from this tap`);
+    }
+    console.log();
+  }
+}
+export {
+  tapAddCommand,
+  tapListCommand,
+  tapRemoveCommand
+};