@webgrow/skillhub 0.1.0

package/src/cloud-catalog.mjs

@@ -0,0 +1,588 @@
+import { ConvexHttpClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+import dotenv from "dotenv";
+import { createInterface } from "node:readline/promises";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { getRuntimeConfig } from "./config.mjs";
+
+dotenv.config({ path: ".env", quiet: true });
+dotenv.config({ path: ".env.local", quiet: true });
+dotenv.config({ path: "bridge/.env.local", quiet: true });
+
+const refs = {
+  loops: {
+    list: makeFunctionReference("loops:list"),
+    run: makeFunctionReference("loops:run"),
+  },
+  skills: {
+    list: makeFunctionReference("skills:list"),
+    runTest: makeFunctionReference("skills:runTest"),
+  },
+  runs: {
+    getRun: makeFunctionReference("runs:getRun"),
+    listRecent: makeFunctionReference("runs:listRecent"),
+  },
+};
+
+export async function runCloudCatalogCommand(argv, io = process) {
+  const [subcommand = "run", ...rest] = argv;
+
+  if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    return showHelp();
+  }
+
+  if (subcommand === "list" || subcommand === "options") {
+    return listOptions(rest, io);
+  }
+
+  if (subcommand === "run" || subcommand === "choose") {
+    return runSelection(rest, io);
+  }
+
+  if (subcommand === "status") {
+    return showStatus(rest);
+  }
+
+  return runSelection(argv, io);
+}
+
+export async function getCloudCatalogItems({
+  filter = "",
+  kind = "",
+  limit = 100,
+  query = "",
+} = {}) {
+  const catalog = await fetchCatalog({ limit });
+  return filterCatalog(catalog, {
+    filter,
+    kind: normalizeKind(kind),
+    query,
+  });
+}
+
+export async function runCloudCatalogItem({
+  filter = "",
+  kind = "",
+  limit = 100,
+  prompt = "",
+  query = "",
+  target = "",
+} = {}) {
+  const items = await getCloudCatalogItems({ filter, kind, limit, query });
+  const selected = target
+    ? matchSelection(items, target)
+    : items.length === 1
+      ? items[0]
+      : null;
+
+  if (!selected) {
+    return {
+      ok: false,
+      reason: items.length ? "ambiguous_selection" : "no_matches",
+      items,
+    };
+  }
+
+  const client = createClient();
+  const promptOverride = cleanOptional(prompt);
+  const result =
+    selected.kind === "loop"
+      ? await client.mutation(refs.loops.run, {
+          loopId: selected.id,
+          promptOverride,
+        })
+      : await client.mutation(refs.skills.runTest, {
+          skillId: selected.id,
+          promptOverride,
+        });
+
+  return {
+    ok: true,
+    selection: selected,
+    runId: result.runId,
+    actionId: result.actionId,
+    message: `Queued ${selected.name}. I will watch the run and report when it completes.`,
+  };
+}
+
+export async function getRunStatus(runId) {
+  const client = createClient();
+  const packet = await client.query(refs.runs.getRun, {
+    runId,
+    eventLimit: 20,
+    logLimit: 20,
+  });
+  if (!packet?.run) {
+    return { ok: false, reason: "run_not_found", runId };
+  }
+
+  return {
+    ok: true,
+    run: summarizeRun(packet.run),
+    hostActions: packet.hostActions.map(summarizeAction),
+    latestEvent: packet.events.at(-1) ?? null,
+    latestLog: packet.logs.at(-1) ?? null,
+  };
+}
+
+export async function listRecentRuns({ limit = 10 } = {}) {
+  const client = createClient();
+  const runs = await client.query(refs.runs.listRecent, {
+    limit: Math.max(1, Math.min(Number(limit || 10), 50)),
+  });
+  return {
+    ok: true,
+    runs: runs.map(summarizeRun),
+  };
+}
+
+export async function watchRun({
+  runId,
+  timeoutSeconds = 60,
+  intervalMs = 2000,
+} = {}) {
+  if (!runId) {
+    return { ok: false, reason: "runId_required" };
+  }
+
+  const startedAt = Date.now();
+  const timeoutMs = Math.max(1000, Math.min(Number(timeoutSeconds || 60) * 1000, 5 * 60_000));
+  const waitMs = Math.max(500, Math.min(Number(intervalMs || 2000), 10_000));
+  let latest = await getRunStatus(runId);
+
+  while (latest.ok && !isTerminalRun(latest.run.status) && Date.now() - startedAt < timeoutMs) {
+    await sleep(waitMs);
+    latest = await getRunStatus(runId);
+  }
+
+  return {
+    ...latest,
+    timedOut: latest.ok ? !isTerminalRun(latest.run.status) : false,
+    watchedMs: Date.now() - startedAt,
+  };
+}
+
+async function listOptions(argv, io) {
+  const flags = parseFlags(argv);
+  const items = await getCloudCatalogItems(flags);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ items }, null, 2));
+    return;
+  }
+
+  console.log(renderCatalog(items));
+  console.log("");
+  console.log("Run one with: skillhub run <number>");
+  console.log("Or open the picker with: skillhub choose");
+}
+
+async function runSelection(argv, io) {
+  const flags = parseFlags(argv);
+  const items = await getCloudCatalogItems(flags);
+  const selected = await resolveSelection(items, flags, io);
+
+  if (!selected) {
+    if (flags.json) {
+      console.log(JSON.stringify({ ok: false, reason: "no_selection", items }, null, 2));
+      return;
+    }
+
+    console.log(renderCatalog(items));
+    console.log("");
+    console.log("Pick a number with: skillhub run <number>");
+    return;
+  }
+
+  const client = createClient();
+  const promptOverride = cleanOptional(flags.prompt);
+  const result =
+    selected.kind === "loop"
+      ? await client.mutation(refs.loops.run, {
+          loopId: selected.id,
+          promptOverride,
+        })
+      : await client.mutation(refs.skills.runTest, {
+          skillId: selected.id,
+          promptOverride,
+        });
+
+  const payload = {
+    ok: true,
+    selection: selected,
+    runId: result.runId,
+    actionId: result.actionId,
+    message: `Queued ${selected.name}. I will watch the run and report when it completes.`,
+  };
+
+  if (flags.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  console.log(`Queued ${selected.kind}: ${selected.name}`);
+  console.log(`Run id: ${result.runId}`);
+  console.log(`Action id: ${result.actionId}`);
+  console.log("Watch it in Codex with: skillhub status");
+  console.log("Or keep the local bridge running with: skillhub bridge start");
+}
+
+async function showStatus(argv) {
+  const flags = parseFlags(argv);
+  const target = flags.target || flags.pick;
+
+  if (target) {
+    const status = await getRunStatus(target);
+    if (flags.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    printRunStatus(status);
+    return;
+  }
+
+  const recent = await listRecentRuns({ limit: flags.limit || 10 });
+  if (flags.json) {
+    console.log(JSON.stringify(recent, null, 2));
+    return;
+  }
+  console.log(renderRecentRuns(recent.runs));
+}
+
+async function fetchCatalog({ limit }) {
+  const client = createClient();
+  const size = Math.max(1, Math.min(Number(limit || 100), 200));
+  const [loopRows, skillRows] = await Promise.all([
+    client.query(refs.loops.list, { limit: size }),
+    client.query(refs.skills.list, { limit: size }),
+  ]);
+
+  return {
+    loops: loopRows.map(toLoopItem),
+    skills: skillRows.map(toSkillItem),
+  };
+}
+
+function createClient() {
+  const config = getRuntimeConfig();
+  const convexUrl = config.convexUrl;
+  if (!convexUrl) {
+    throw new Error("Run skillhub connect before using SkillHub options.");
+  }
+
+  const client = new ConvexHttpClient(convexUrl);
+  if (process.env.CONVEX_AUTH_TOKEN) {
+    client.setAuth(process.env.CONVEX_AUTH_TOKEN);
+  }
+  return client;
+}
+
+function summarizeRun(run) {
+  return {
+    id: run._id,
+    loopSlug: run.loopSlug,
+    status: run.status,
+    activeNodeId: run.activeNodeId ?? null,
+    prompt: run.prompt ?? "",
+    summary: run.summary ?? "",
+    startedAt: run.startedAt,
+    completedAt: run.completedAt ?? null,
+    updatedAt: run.updatedAt,
+  };
+}
+
+function summarizeAction(action) {
+  return {
+    id: action._id,
+    title: action.title,
+    status: action.status,
+    actionType: action.actionType,
+    error: action.error ?? "",
+    updatedAt: action.updatedAt,
+  };
+}
+
+function printRunStatus(status) {
+  if (!status.ok) {
+    console.log(`Run not found: ${status.runId}`);
+    return;
+  }
+
+  console.log(`${status.run.loopSlug}: ${status.run.status}`);
+  console.log(`Run id: ${status.run.id}`);
+  if (status.hostActions.length) {
+    console.log("");
+    console.log("Actions");
+    for (const action of status.hostActions) {
+      console.log(`- ${action.title}: ${action.status}`);
+    }
+  }
+}
+
+function renderRecentRuns(runs) {
+  if (!runs.length) return "No recent runs.";
+  return [
+    "Recent runs",
+    ...runs.map((run, index) => `${index + 1}. ${run.loopSlug} - ${run.status} (${run.id})`),
+  ].join("\n");
+}
+
+function toLoopItem({ loop, latestVersion, draftVersion }) {
+  const version = latestVersion ?? draftVersion;
+  const manifest = version?.manifest ?? {};
+  return {
+    kind: "loop",
+    id: loop._id,
+    slug: loop.slug,
+    name: loop.name,
+    description: loop.description ?? manifest.objective ?? "",
+    status: latestVersion ? "published" : draftVersion ? "draft" : "empty",
+    version: version?.version ?? null,
+    tags: loop.tags ?? [],
+    updatedAt: loop.updatedAt,
+    stepCount: Array.isArray(manifest.steps) ? manifest.steps.length : 0,
+  };
+}
+
+function toSkillItem({ skill, latestVersion, draftVersion }) {
+  const version = latestVersion ?? draftVersion;
+  return {
+    kind: "skill",
+    id: skill._id,
+    slug: skill.slug,
+    name: skill.name,
+    description: skill.summary ?? version?.testPrompt ?? "",
+    status: latestVersion ? "published" : draftVersion ? "draft" : "empty",
+    version: version?.version ?? null,
+    tags: skill.tags ?? [],
+    updatedAt: skill.updatedAt,
+  };
+}
+
+function filterCatalog(catalog, flags) {
+  let items = [];
+  if (flags.kind !== "skill") items.push(...catalog.loops);
+  if (flags.kind !== "loop") items.push(...catalog.skills);
+
+  const query = cleanOptional(flags.query || flags.filter);
+  if (query) {
+    const needle = query.toLowerCase();
+    items = items.filter((item) =>
+      [
+        item.kind,
+        item.slug,
+        item.name,
+        item.description,
+        item.status,
+        ...(item.tags ?? []),
+      ]
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase()
+        .includes(needle),
+    );
+  }
+
+  return items.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+async function resolveSelection(items, flags, io) {
+  const target = flags.pick || flags.target;
+  if (target) {
+    return matchSelection(items, target);
+  }
+
+  if (!items.length || flags.noPrompt || !io.stdin?.isTTY) {
+    return null;
+  }
+
+  console.log(renderCatalog(items));
+  console.log("");
+  const rl = createInterface({
+    input: io.stdin,
+    output: io.stdout,
+  });
+
+  try {
+    const answer = await rl.question("Choose a number, or type search text: ");
+    const direct = matchSelection(items, answer);
+    if (direct) return direct;
+
+    const narrowed = filterCatalog({ loops: items.filter(isLoop), skills: items.filter(isSkill) }, {
+      query: answer,
+    });
+    if (narrowed.length === 1) return narrowed[0];
+    if (!narrowed.length) return null;
+
+    console.log("");
+    console.log(renderCatalog(narrowed));
+    console.log("");
+    const secondAnswer = await rl.question("Choose a number from these matches: ");
+    return matchSelection(narrowed, secondAnswer);
+  } finally {
+    rl.close();
+  }
+}
+
+function matchSelection(items, target) {
+  const cleaned = cleanOptional(String(target));
+  if (!cleaned) return null;
+
+  if (/^\d+$/.test(cleaned)) {
+    return items[Number(cleaned) - 1] ?? null;
+  }
+
+  const needle = cleaned.toLowerCase();
+  const exact = items.find(
+    (item) =>
+      item.id.toLowerCase() === needle ||
+      item.slug.toLowerCase() === needle ||
+      item.name.toLowerCase() === needle,
+  );
+  if (exact) return exact;
+
+  const fuzzy = items.filter((item) =>
+    [item.slug, item.name, item.description, ...(item.tags ?? [])]
+      .filter(Boolean)
+      .join(" ")
+      .toLowerCase()
+      .includes(needle),
+  );
+  return fuzzy.length === 1 ? fuzzy[0] : null;
+}
+
+export function renderCatalog(items) {
+  if (!items.length) {
+    return "No loops or skills matched.";
+  }
+
+  const loopItems = items.filter(isLoop);
+  const skillItems = items.filter(isSkill);
+  const sections = [];
+  let offset = 0;
+
+  if (loopItems.length) {
+    sections.push(renderSection("Loops", loopItems, offset));
+    offset += loopItems.length;
+  }
+
+  if (skillItems.length) {
+    sections.push(renderSection("Skills", skillItems, offset));
+  }
+
+  return sections.join("\n\n");
+}
+
+function renderSection(title, items, offset) {
+  return [
+    title,
+    ...items.map((item, index) => {
+      const number = offset + index + 1;
+      const meta = [
+        item.status,
+        item.version,
+        item.stepCount ? `${item.stepCount} step${item.stepCount === 1 ? "" : "s"}` : null,
+        item.tags?.length ? item.tags.join(", ") : null,
+      ]
+        .filter(Boolean)
+        .join(" | ");
+      const description = item.description ? ` - ${item.description}` : "";
+      return `${number}. ${item.name} (${item.slug}) [${meta}]${description}`;
+    }),
+  ].join("\n");
+}
+
+function showHelp() {
+  console.log(`SkillHub options
+
+Commands:
+  skillhub options                         Show available loops and skills
+  skillhub choose                          Open a numbered picker and run one
+  skillhub run                             Same as choose
+  skillhub run <number|slug|name>          Run a selected loop or skill
+  skillhub run loop <number|slug|name>     Run a loop from the loop list
+  skillhub run skill <number|slug|name>    Run a skill from the skill list
+
+Flags:
+  --query <text>                           Filter by name, slug, tag, or summary
+  --prompt <text>                          Override the run/test prompt
+  --json                                   Return machine-readable output
+  --no-prompt                              Print options instead of opening a picker
+`);
+}
+
+function parseFlags(argv) {
+  const flags = {
+    filter: "",
+    json: false,
+    kind: "",
+    limit: 100,
+    noPrompt: false,
+    pick: "",
+    prompt: "",
+    query: "",
+    target: "",
+  };
+  const positional = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--filter") flags.filter = argv[++index] ?? "";
+    else if (arg === "--json") flags.json = true;
+    else if (arg === "--kind" || arg === "--type") flags.kind = normalizeKind(argv[++index] ?? "");
+    else if (arg === "--limit") flags.limit = Number(argv[++index] ?? 100);
+    else if (arg === "--no-prompt") flags.noPrompt = true;
+    else if (arg === "--pick") flags.pick = argv[++index] ?? "";
+    else if (arg === "--prompt") flags.prompt = argv[++index] ?? "";
+    else if (arg === "--query" || arg === "-q") flags.query = argv[++index] ?? "";
+    else positional.push(arg);
+  }
+
+  if (positional[0] === "loop" || positional[0] === "loops") {
+    flags.kind = "loop";
+    flags.target = positional.slice(1).join(" ");
+  } else if (positional[0] === "skill" || positional[0] === "skills") {
+    flags.kind = "skill";
+    flags.target = positional.slice(1).join(" ");
+  } else {
+    flags.target = positional.join(" ");
+  }
+
+  return flags;
+}
+
+function isTerminalRun(status) {
+  return ["completed", "failed", "canceled"].includes(status);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function normalizeKind(value) {
+  if (value === "loops") return "loop";
+  if (value === "skills") return "skill";
+  if (value === "loop" || value === "skill") return value;
+  return "";
+}
+
+function isLoop(item) {
+  return item.kind === "loop";
+}
+
+function isSkill(item) {
+  return item.kind === "skill";
+}
+
+function cleanOptional(value) {
+  const cleaned = value?.trim();
+  return cleaned ? cleaned : "";
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await runCloudCatalogCommand(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}