selftune 0.2.22 → 0.2.24

package/cli/selftune/registry/client.ts

@@ -0,0 +1,74 @@
+/**
+ * Registry HTTP client. Never throws — returns typed results.
+ */
+
+import { getSelftuneVersion } from "../utils/selftune-meta.js";
+
+export interface RegistryResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  status?: number;
+}
+
+function getConfig(): { apiUrl: string; apiKey: string } | null {
+  try {
+    const configPath = `${process.env.HOME}/.selftune/config.json`;
+    const raw = require("fs").readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    const apiUrl = config?.alpha?.cloud_api_url || "https://api.selftune.dev";
+    const apiKey = config?.alpha?.api_key;
+    if (!apiKey) return null;
+    return { apiUrl, apiKey };
+  } catch {
+    return null;
+  }
+}
+
+export async function registryRequest<T>(
+  method: string,
+  path: string,
+  opts?: { body?: unknown; formData?: FormData },
+): Promise<RegistryResult<T>> {
+  const config = getConfig();
+  if (!config) {
+    return { success: false, error: "Not authenticated. Run 'selftune alpha upload' to set up." };
+  }
+
+  try {
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${config.apiKey}`,
+      "User-Agent": `selftune/${getSelftuneVersion()}`,
+    };
+
+    let fetchBody: BodyInit | undefined;
+    if (opts?.formData) {
+      fetchBody = opts.formData;
+      // Don't set Content-Type — fetch sets multipart boundary automatically
+    } else if (opts?.body) {
+      headers["Content-Type"] = "application/json";
+      fetchBody = JSON.stringify(opts.body);
+    }
+
+    const response = await fetch(`${config.apiUrl}/api/v1/registry${path}`, {
+      method,
+      headers,
+      body: fetchBody,
+      signal: AbortSignal.timeout(60_000),
+    });
+
+    const text = await response.text();
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `HTTP ${response.status}: ${text.slice(0, 300)}`,
+        status: response.status,
+      };
+    }
+
+    const data = text ? JSON.parse(text) : {};
+    return { success: true, data: data as T, status: response.status };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}

package/cli/selftune/registry/history.ts

@@ -0,0 +1,54 @@
+/**
+ * selftune registry history — Show version timeline for a skill.
+ */
+
+import { registryRequest } from "./client.js";
+
+export async function cliMain() {
+  const args = process.argv.slice(2);
+  const name = args.find((a) => !a.startsWith("--"));
+
+  if (!name) {
+    console.error(JSON.stringify({ error: "Usage: selftune registry history <name>" }));
+    process.exit(1);
+  }
+
+  const listResult = await registryRequest<{ entries: Array<{ id: string }> }>(
+    "GET",
+    `?name=${encodeURIComponent(name)}`,
+  );
+  if (!listResult.success || !listResult.data?.entries?.length) {
+    console.error(JSON.stringify({ error: `Skill '${name}' not found in registry` }));
+    process.exit(1);
+  }
+
+  const entryId = listResult.data.entries[0].id;
+  const result = await registryRequest<{
+    versions: Array<{
+      version: string;
+      is_current: boolean;
+      rolled_back: boolean;
+      aggregate_pass_rate: number | null;
+      aggregate_sessions: number;
+      change_summary: string | null;
+      pushed_at: string;
+    }>;
+  }>("GET", `/${entryId}/versions`);
+
+  if (!result.success) {
+    console.error(JSON.stringify({ error: result.error }));
+    process.exit(1);
+  }
+
+  const versions = result.data?.versions || [];
+  const timeline = versions.map((v) => ({
+    version: v.version,
+    status: v.is_current ? "current" : v.rolled_back ? "rolled_back" : "previous",
+    pass_rate: v.aggregate_pass_rate,
+    sessions: v.aggregate_sessions,
+    summary: v.change_summary,
+    pushed_at: v.pushed_at,
+  }));
+
+  console.log(JSON.stringify({ name, versions: timeline }));
+}

package/cli/selftune/registry/index.ts

@@ -0,0 +1,90 @@
+/**
+ * selftune registry — Team skill distribution.
+ *
+ * Subcommands:
+ *   push       Push current skill folder as a new version
+ *   install    Download and install a skill from the registry
+ *   sync       Check for updates and pull latest versions
+ *   status     Show installed entries and version drift
+ *   rollback   Rollback a skill to a previous version
+ *   history    Show version timeline for a skill
+ *   list       Show all published entries in the org
+ */
+
+import { CLIError } from "../utils/cli-error.js";
+
+const sub = process.argv[2];
+
+export async function cliMain() {
+  if (!sub || sub === "--help" || sub === "-h") {
+    console.log(`selftune registry — Team skill distribution
+
+Usage:
+  selftune registry <subcommand> [options]
+
+Subcommands:
+  push [name]          Push current skill folder as a new version
+  install <name>       Download and install a skill from the registry
+  sync                 Check for updates and pull latest versions
+  status               Show installed entries and version drift
+  rollback <name>      Rollback to a previous version
+  history <name>       Show version timeline
+  list                 Show all published entries
+
+Options:
+  --version=<semver>   Set version explicitly (push)
+  --summary=<text>     Change summary (push)
+  --global             Install to ~/.claude/skills/ (install)
+  --to=<version>       Target version (rollback)
+  --reason=<text>      Rollback reason (rollback)
+`);
+    return;
+  }
+
+  // Strip 'registry' from argv so subcommands see the right args
+  process.argv = [process.argv[0], process.argv[1], ...process.argv.slice(3)];
+
+  switch (sub) {
+    case "push": {
+      const { cliMain } = await import("./push.js");
+      await cliMain();
+      break;
+    }
+    case "install": {
+      const { cliMain } = await import("./install.js");
+      await cliMain();
+      break;
+    }
+    case "sync": {
+      const { cliMain } = await import("./sync.js");
+      await cliMain();
+      break;
+    }
+    case "status": {
+      const { cliMain } = await import("./status.js");
+      await cliMain();
+      break;
+    }
+    case "rollback": {
+      const { cliMain } = await import("./rollback.js");
+      await cliMain();
+      break;
+    }
+    case "history": {
+      const { cliMain } = await import("./history.js");
+      await cliMain();
+      break;
+    }
+    case "list": {
+      const { cliMain } = await import("./list.js");
+      await cliMain();
+      break;
+    }
+    default:
+      throw new CLIError(
+        `Unknown registry subcommand: ${sub}`,
+        "UNKNOWN_COMMAND",
+        "selftune registry --help",
+      );
+  }
+}

package/cli/selftune/registry/install.ts

@@ -0,0 +1,141 @@
+/**
+ * selftune registry install — Download and extract a skill from the registry.
+ */
+
+import { readFileSync } from "node:fs";
+import { mkdir, unlink, writeFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join } from "node:path";
+
+import { registryRequest } from "./client.js";
+
+export async function cliMain() {
+  const args = process.argv.slice(2);
+  const name = args.find((a) => !a.startsWith("--"));
+  const globalFlag = args.includes("--global");
+
+  if (!name) {
+    console.error(
+      JSON.stringify({
+        error: "Usage: selftune registry install <name>",
+        guidance: { next_command: "selftune registry list" },
+      }),
+    );
+    process.exit(1);
+  }
+
+  // Find entry by name
+  const listResult = await registryRequest<{
+    entries: Array<{
+      id: string;
+      name: string;
+      current_version?: { id: string; version: string; content_hash: string };
+    }>;
+  }>("GET", `?name=${encodeURIComponent(name)}`);
+
+  if (!listResult.success || !listResult.data?.entries?.length) {
+    console.error(
+      JSON.stringify({
+        error: `Skill '${name}' not found in registry`,
+        guidance: { next_command: "selftune registry list" },
+      }),
+    );
+    process.exit(1);
+  }
+
+  const entry = listResult.data.entries[0];
+  const entryId = entry.id;
+
+  // Get detail with versions
+  const detailResult = await registryRequest<{
+    entry: { id: string; name: string };
+    versions: Array<{ id: string; version: string; content_hash: string; is_current: boolean }>;
+  }>("GET", `/${entryId}`);
+
+  if (!detailResult.success) {
+    console.error(JSON.stringify({ error: detailResult.error }));
+    process.exit(1);
+  }
+
+  const currentVersion = detailResult.data?.versions?.find((v) => v.is_current);
+  if (!currentVersion) {
+    console.error(JSON.stringify({ error: "No current version found" }));
+    process.exit(1);
+  }
+
+  // Request presigned download via sync
+  const syncResult = await registryRequest<{
+    entries: Array<{
+      download_url?: string;
+      latest_version: string;
+      latest_content_hash: string;
+    }>;
+  }>("POST", "/sync", {
+    body: { installations: [{ entry_id: entryId, current_version_hash: "none" }] },
+  });
+
+  const downloadUrl = syncResult.data?.entries?.[0]?.download_url;
+  if (!downloadUrl) {
+    console.error(JSON.stringify({ error: "Could not get download URL" }));
+    process.exit(1);
+  }
+
+  // Download archive
+  console.log(`Installing ${name} v${currentVersion.version}...`);
+  const response = await fetch(downloadUrl, { signal: AbortSignal.timeout(60_000) });
+  if (!response.ok) {
+    console.error(JSON.stringify({ error: `Download failed: HTTP ${response.status}` }));
+    process.exit(1);
+  }
+  const archiveBuffer = Buffer.from(await response.arrayBuffer());
+
+  // Determine install path
+  const targetBase = globalFlag
+    ? join(process.env.HOME || "~", ".claude", "skills")
+    : join(process.cwd(), ".claude", "skills");
+  const targetDir = join(targetBase, name);
+
+  // Extract archive
+  await mkdir(targetDir, { recursive: true });
+  const archivePath = `/tmp/selftune-install-${Date.now()}.tar.gz`;
+  await writeFile(archivePath, archiveBuffer);
+  const proc = Bun.spawn(["tar", "xzf", archivePath, "-C", targetDir], {
+    stdout: "ignore",
+    stderr: "pipe",
+  });
+  await proc.exited;
+
+  await unlink(archivePath).catch(() => {});
+
+  if (proc.exitCode !== 0) {
+    console.error(JSON.stringify({ error: "Failed to extract archive" }));
+    process.exit(1);
+  }
+
+  // Record installation on server
+  await registryRequest("POST", `/${entryId}/install`, {
+    body: { install_path: targetDir, device_id: hostname() },
+  });
+
+  // Update local state
+  const statePath = join(process.env.HOME || "~", ".selftune", "registry-state.json");
+  let state: Array<{ entryId: string; name: string; versionHash: string; installPath: string }> =
+    [];
+  try {
+    state = JSON.parse(readFileSync(statePath, "utf-8"));
+  } catch {}
+  state = state.filter((s) => s.entryId !== entryId);
+  state.push({ entryId, name, versionHash: currentVersion.content_hash, installPath: targetDir });
+  await mkdir(join(process.env.HOME || "~", ".selftune"), { recursive: true });
+  await writeFile(statePath, JSON.stringify(state, null, 2));
+
+  console.log(
+    JSON.stringify({
+      success: true,
+      name,
+      version: currentVersion.version,
+      path: targetDir,
+      global: globalFlag,
+    }),
+  );
+}

package/cli/selftune/registry/list.ts

@@ -0,0 +1,44 @@
+/**
+ * selftune registry list — Show all published entries in the org.
+ */
+
+import { registryRequest } from "./client.js";
+
+export async function cliMain() {
+  const result = await registryRequest<{
+    entries: Array<{
+      name: string;
+      entry_type: string;
+      description: string | null;
+      current_version?: { version: string };
+      pass_rate: number | null;
+      eval_count: number;
+    }>;
+  }>("GET", "");
+
+  if (!result.success) {
+    console.error(JSON.stringify({ error: result.error }));
+    process.exit(1);
+  }
+
+  const entries = result.data?.entries || [];
+  if (entries.length === 0) {
+    console.log(
+      JSON.stringify({
+        message: "No entries in registry. Use 'selftune registry push' to publish a skill.",
+      }),
+    );
+    return;
+  }
+
+  const table = entries.map((e) => ({
+    name: e.name,
+    type: e.entry_type,
+    version: e.current_version?.version || "—",
+    pass_rate: e.pass_rate,
+    eval_count: e.eval_count,
+    description: e.description,
+  }));
+
+  console.log(JSON.stringify({ entries: table, total: entries.length }));
+}

package/cli/selftune/registry/push.ts

@@ -0,0 +1,171 @@
+/**
+ * selftune registry push — Archive and upload a skill folder as a new version.
+ */
+
+import { createHash } from "node:crypto";
+import { readdir, readFile, stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
+
+import { registryRequest } from "./client.js";
+
+interface FileManifestEntry {
+  path: string;
+  hash: string;
+  size: number;
+}
+
+async function collectFiles(
+  dir: string,
+  base?: string,
+): Promise<{ path: string; content: Buffer }[]> {
+  const files: { path: string; content: Buffer }[] = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relPath = base ? join(base, entry.name) : entry.name;
+    if (
+      entry.name === ".git" ||
+      entry.name === "node_modules" ||
+      entry.name === ".env" ||
+      entry.name.startsWith(".env.")
+    )
+      continue;
+    if (entry.isDirectory()) {
+      files.push(...(await collectFiles(fullPath, relPath)));
+    } else {
+      files.push({ path: relPath, content: await readFile(fullPath) });
+    }
+  }
+  return files;
+}
+
+export async function cliMain() {
+  const args = process.argv.slice(2);
+  const nameArg = args.find((a) => !a.startsWith("--"));
+  const versionFlag = args.find((a) => a.startsWith("--version="))?.slice("--version=".length);
+  const summaryFlag = args.find((a) => a.startsWith("--summary="))?.slice("--summary=".length);
+
+  // Find skill folder
+  const cwd = process.cwd();
+  const skillMd = join(cwd, "SKILL.md");
+  try {
+    await stat(skillMd);
+  } catch {
+    console.error(
+      JSON.stringify({
+        error: "No SKILL.md found in current directory. Navigate to a skill folder first.",
+        guidance: { next_command: "cd <skill-directory>" },
+      }),
+    );
+    process.exit(1);
+  }
+
+  // Read SKILL.md to extract name and description
+  const skillContent = await readFile(skillMd, "utf-8");
+  const nameMatch = skillContent.match(/^name:\s*(.+)$/m);
+  const descMatch = skillContent.match(/^description:\s*(.+)$/m);
+  const name = nameArg || nameMatch?.[1]?.trim() || "unnamed-skill";
+  const description = descMatch?.[1]?.trim() || "";
+
+  // Collect all files
+  const files = await collectFiles(cwd);
+  const manifest: FileManifestEntry[] = files.map((f) => ({
+    path: f.path,
+    hash: createHash("sha256").update(f.content).digest("hex"),
+    size: f.content.length,
+  }));
+
+  // Create tar.gz archive using system tar (available on all platforms)
+  const archivePath = `/tmp/selftune-registry-${Date.now()}.tar.gz`;
+  const proc = Bun.spawn(
+    [
+      "tar",
+      "czf",
+      archivePath,
+      "-C",
+      cwd,
+      "--exclude=.git",
+      "--exclude=node_modules",
+      "--exclude=.env",
+      "--exclude=.env.*",
+      ".",
+    ],
+    {
+      stdout: "ignore",
+      stderr: "pipe",
+    },
+  );
+  await proc.exited;
+  if (proc.exitCode !== 0) {
+    console.error(JSON.stringify({ error: "Failed to create archive" }));
+    process.exit(1);
+  }
+  const archiveBuffer = await readFile(archivePath);
+  const archiveHash = createHash("sha256").update(archiveBuffer).digest("hex");
+
+  // Clean up temp file
+  await unlink(archivePath).catch(() => {});
+
+  // Determine version
+  const version = versionFlag || `0.1.${Date.now()}`;
+
+  // Build multipart form
+  const formData = new FormData();
+  formData.append(
+    "metadata",
+    JSON.stringify({
+      name,
+      entry_type: "skill",
+      description,
+      version,
+      change_summary: summaryFlag || undefined,
+      file_manifest: manifest,
+      content_hash: archiveHash,
+    }),
+  );
+  formData.append(
+    "archive",
+    new Blob([archiveBuffer], { type: "application/gzip" }),
+    `${name}.tar.gz`,
+  );
+
+  // Try to push as new version first, fall back to create
+  console.log(
+    `Pushing ${name} v${version} (${(archiveBuffer.length / 1024).toFixed(1)} KB, ${files.length} files)...`,
+  );
+
+  // First check if entry exists
+  const listResult = await registryRequest<{ entries: Array<{ id: string; name: string }> }>(
+    "GET",
+    `?name=${encodeURIComponent(name)}`,
+  );
+
+  let result;
+  if (listResult.success && listResult.data?.entries?.length) {
+    const entryId = listResult.data.entries[0].id;
+    result = await registryRequest("POST", `/${entryId}/versions`, { formData });
+  } else {
+    result = await registryRequest("POST", "", { formData });
+  }
+
+  if (result.success) {
+    console.log(
+      JSON.stringify({
+        success: true,
+        name,
+        version,
+        files: files.length,
+        size: archiveBuffer.length,
+        hash: archiveHash,
+      }),
+    );
+  } else {
+    console.error(
+      JSON.stringify({
+        error: result.error,
+        guidance: { next_command: "selftune registry list" },
+      }),
+    );
+    process.exit(1);
+  }
+}

package/cli/selftune/registry/rollback.ts

@@ -0,0 +1,49 @@
+/**
+ * selftune registry rollback — Rollback a skill to a previous version.
+ */
+
+import { registryRequest } from "./client.js";
+
+export async function cliMain() {
+  const args = process.argv.slice(2);
+  const name = args.find((a) => !a.startsWith("--"));
+  const toVersion = args.find((a) => a.startsWith("--to="))?.slice("--to=".length);
+  const reason = args.find((a) => a.startsWith("--reason="))?.slice("--reason=".length);
+
+  if (!name) {
+    console.error(
+      JSON.stringify({
+        error: "Usage: selftune registry rollback <name> [--to=version] [--reason=text]",
+      }),
+    );
+    process.exit(1);
+  }
+
+  // Find entry
+  const listResult = await registryRequest<{ entries: Array<{ id: string; name: string }> }>(
+    "GET",
+    `?name=${encodeURIComponent(name)}`,
+  );
+  if (!listResult.success || !listResult.data?.entries?.length) {
+    console.error(JSON.stringify({ error: `Skill '${name}' not found in registry` }));
+    process.exit(1);
+  }
+
+  const entryId = listResult.data.entries[0].id;
+  const result = await registryRequest("POST", `/${entryId}/rollback`, {
+    body: { target_version: toVersion, reason },
+  });
+
+  if (result.success) {
+    console.log(
+      JSON.stringify({
+        success: true,
+        name,
+        message: "Rolled back. Run 'selftune registry sync' to update local installations.",
+      }),
+    );
+  } else {
+    console.error(JSON.stringify({ error: result.error }));
+    process.exit(1);
+  }
+}

package/cli/selftune/registry/status.ts

@@ -0,0 +1,62 @@
+/**
+ * selftune registry status — Show installed entries and version drift.
+ */
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { registryRequest } from "./client.js";
+
+export async function cliMain() {
+  const statePath = join(process.env.HOME || "~", ".selftune", "registry-state.json");
+  let state: Array<{ entryId: string; name: string; versionHash: string; installPath: string }>;
+  try {
+    state = JSON.parse(await readFile(statePath, "utf-8"));
+  } catch {
+    console.log(JSON.stringify({ message: "No registry installations found." }));
+    return;
+  }
+
+  if (state.length === 0) {
+    console.log(JSON.stringify({ message: "No registry installations found." }));
+    return;
+  }
+
+  const syncResult = await registryRequest<{
+    entries: Array<{
+      entry_id: string;
+      name: string;
+      has_update: boolean;
+      latest_version: string;
+      current_version: string;
+    }>;
+  }>("POST", "/sync", {
+    body: {
+      installations: state.map((s) => ({
+        entry_id: s.entryId,
+        current_version_hash: s.versionHash,
+      })),
+    },
+  });
+
+  if (!syncResult.success) {
+    console.error(JSON.stringify({ error: syncResult.error }));
+    process.exit(1);
+  }
+
+  const entries = syncResult.data?.entries || [];
+  const table = entries.map((e) => ({
+    name: e.name,
+    installed: e.current_version,
+    latest: e.latest_version,
+    status: e.has_update ? "behind" : "up-to-date",
+  }));
+
+  console.log(
+    JSON.stringify({
+      installations: table,
+      total: state.length,
+      updates_available: entries.filter((e) => e.has_update).length,
+    }),
+  );
+}