selftune 0.2.21 → 0.2.23

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,
+    }),
+  );
+}

package/cli/selftune/registry/sync.ts

@@ -0,0 +1,125 @@
+/**
+ * selftune registry sync — Check for updates and pull latest versions.
+ */
+
+import { writeFile, readFile, mkdir, unlink } from "node:fs/promises";
+import { join } from "node:path";
+
+import { registryRequest } from "./client.js";
+
+interface LocalState {
+  entryId: string;
+  name: string;
+  versionHash: string;
+  installPath: string;
+}
+
+function getStatePath(): string {
+  return join(process.env.HOME || "~", ".selftune", "registry-state.json");
+}
+
+async function loadState(): Promise<LocalState[]> {
+  try {
+    const raw = await readFile(getStatePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+async function saveState(state: LocalState[]): Promise<void> {
+  await mkdir(join(process.env.HOME || "~", ".selftune"), { recursive: true });
+  await writeFile(getStatePath(), JSON.stringify(state, null, 2));
+}
+
+export async function cliMain() {
+  const state = await loadState();
+  if (state.length === 0) {
+    console.log(
+      JSON.stringify({
+        message: "No registry installations found. Use 'selftune registry install <name>' first.",
+      }),
+    );
+    return;
+  }
+
+  // Check for updates
+  const syncResult = await registryRequest<{
+    entries: Array<{
+      entry_id: string;
+      name: string;
+      has_update: boolean;
+      latest_version: string;
+      latest_content_hash: string;
+      download_url?: 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 updates = syncResult.data?.entries?.filter((e) => e.has_update) || [];
+  if (updates.length === 0) {
+    console.log(JSON.stringify({ message: "All installations up to date", count: state.length }));
+    return;
+  }
+
+  console.log(`Found ${updates.length} update(s)...`);
+  let synced = 0;
+  let failed = 0;
+
+  for (const update of updates) {
+    if (!update.download_url) {
+      failed++;
+      continue;
+    }
+
+    const localEntry = state.find((s) => s.entryId === update.entry_id);
+    if (!localEntry) {
+      failed++;
+      continue;
+    }
+
+    try {
+      const response = await fetch(update.download_url, { signal: AbortSignal.timeout(60_000) });
+      if (!response.ok) {
+        failed++;
+        continue;
+      }
+
+      const archiveBuffer = Buffer.from(await response.arrayBuffer());
+      const archivePath = `/tmp/selftune-sync-${Date.now()}.tar.gz`;
+      await writeFile(archivePath, archiveBuffer);
+
+      // Extract to existing install path
+      const proc = Bun.spawn(["tar", "xzf", archivePath, "-C", localEntry.installPath], {
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+      await proc.exited;
+      await unlink(archivePath).catch(() => {});
+
+      if (proc.exitCode === 0) {
+        localEntry.versionHash = update.latest_content_hash;
+        synced++;
+        console.log(`  updated: ${update.name} -> v${update.latest_version}`);
+      } else {
+        failed++;
+      }
+    } catch {
+      failed++;
+    }
+  }
+
+  await saveState(state);
+  console.log(JSON.stringify({ synced, failed, total: state.length }));
+}

package/cli/selftune/repair/skill-usage.ts

@@ -31,6 +31,7 @@ import {
   findInstalledSkillPath,
   findRepositoryClaudeSkillDirs,
   findRepositorySkillDirs,
+  isTestFixturePath,
 } from "../utils/skill-discovery.js";
 import { writeRepairedSkillUsageRecords } from "../utils/skill-log.js";
 
@@ -380,7 +381,7 @@ function extractSessionSkillUsage(
 
       if (toolName === "Read") {
         const filePath = (input.file_path as string) ?? "";
-        if (filePath.endsWith("SKILL.md")) {
+        if (filePath.endsWith("SKILL.md") && !isTestFixturePath(filePath)) {
           const inferredSkillName = basename(dirname(filePath)).trim();
           if (inferredSkillName && !skillPathLookup.has(inferredSkillName)) {
             skillPathLookup.set(inferredSkillName.toLowerCase(), filePath);
@@ -421,6 +422,8 @@ function extractSessionSkillUsage(
         ? { skillPath: knownSkillPath, resolutionSource: "raw_log" as const }
         : resolveClaudeSkillPath(skillName, sessionCwd, homeDir, codexHome);
 
+      if (isTestFixturePath(skillPath)) continue;
+
       const recordIndex =
         repaired.push({
           timestamp: timestamp || lastUserMessage.timestamp || fallbackTimestamp,

package/cli/selftune/status.ts

@@ -17,6 +17,7 @@ import { getQueueStats } from "./alpha-upload/queue.js";
 import { getBaseUrl } from "./auth/device-code.js";
 import { SELFTUNE_CONFIG_PATH } from "./constants.js";
 import { getDb } from "./localdb/db.js";
+import { writeCronRunToDb } from "./localdb/direct-write.js";
 import {
   getLastUploadError,
   getLastUploadSuccess,
@@ -576,6 +577,8 @@ export function formatAlphaStatus(info: AlphaStatusInfo | null): string {
 
 export async function cliMain(): Promise<void> {
   const db = getDb();
+  const statusStartedAt = new Date();
+  const statusStart = performance.now();
   try {
     const telemetry = querySessionTelemetry(db) as SessionTelemetryRecord[];
     const skillRecords = querySkillUsageRecords(db) as SkillUsageRecord[];
@@ -610,9 +613,37 @@ export async function cliMain(): Promise<void> {
     }
     console.log(formatAlphaStatus(alphaInfo));
 
+    // Log cron run for unified timeline visibility
+    const statusElapsed = Math.round(performance.now() - statusStart);
+    writeCronRunToDb(db, {
+      jobName: "status",
+      startedAt: statusStartedAt.toISOString(),
+      elapsedMs: statusElapsed,
+      status: "success",
+      metrics: {
+        total_skills: result.skills.length,
+        healthy: result.skills.filter((s) => s.status === "HEALTHY").length,
+        warning: result.skills.filter((s) => s.status === "WARNING").length,
+        critical: result.skills.filter((s) => s.status === "CRITICAL").length,
+        system_healthy: result.system.healthy,
+        unmatched_queries: result.unmatchedQueries,
+        pending_proposals: result.pendingProposals,
+      },
+    });
+
     process.exit(0);
   } catch (err) {
+    // Log failed status run
+    const statusElapsed = Math.round(performance.now() - statusStart);
     const message = err instanceof Error ? err.message : String(err);
+    writeCronRunToDb(db, {
+      jobName: "status",
+      startedAt: statusStartedAt.toISOString(),
+      elapsedMs: statusElapsed,
+      status: "error",
+      error: message,
+    });
+
     console.error(`selftune status failed: ${message}`);
     process.exit(1);
   }