@dhruvwill/skills-cli 1.0.0

package/src/commands/status.ts

@@ -0,0 +1,84 @@
+import chalk from "chalk";
+import Table from "cli-table3";
+import { getSources, getTargets } from "../lib/config.ts";
+import { SKILLS_ROOT, SKILLS_STORE, getNamespacePath } from "../lib/paths.ts";
+import { directoryExists, compareDirectories } from "../lib/hash.ts";
+
+/**
+ * Show status overview of sources, targets, and sync state
+ */
+export async function status(): Promise<void> {
+  console.log();
+  console.log(chalk.bold("Skills Status"));
+  console.log(chalk.dim("─".repeat(50)));
+
+  // Paths
+  console.log();
+  console.log(chalk.bold("Paths"));
+  console.log(`  Root:   ${chalk.cyan(SKILLS_ROOT)}`);
+  console.log(`  Store:  ${chalk.cyan(SKILLS_STORE)}`);
+
+  // Sources summary
+  const sources = await getSources();
+  console.log();
+  console.log(chalk.bold(`Sources (${sources.length})`));
+  
+  if (sources.length === 0) {
+    console.log(chalk.dim("  No sources registered"));
+  } else {
+    for (const source of sources) {
+      const exists = await directoryExists(getNamespacePath(source.namespace));
+      const icon = exists ? chalk.green("●") : chalk.red("●");
+      const typeLabel = source.type === "remote" ? chalk.blue("remote") : chalk.magenta("local");
+      console.log(`  ${icon} ${source.namespace} ${chalk.dim(`(${typeLabel})`)}`);
+    }
+  }
+
+  // Targets summary
+  const targets = await getTargets();
+  console.log();
+  console.log(chalk.bold(`Targets (${targets.length})`));
+  
+  if (targets.length === 0) {
+    console.log(chalk.dim("  No targets registered"));
+  } else {
+    for (const target of targets) {
+      const syncStatus = await compareDirectories(SKILLS_STORE, target.path);
+      let icon: string;
+      let statusText: string;
+      
+      if (syncStatus === "synced") {
+        icon = chalk.green("●");
+        statusText = chalk.green("synced");
+      } else if (syncStatus === "not synced") {
+        icon = chalk.yellow("●");
+        statusText = chalk.yellow("outdated");
+      } else {
+        icon = chalk.red("●");
+        statusText = chalk.red("missing");
+      }
+      
+      console.log(`  ${icon} ${target.name} ${chalk.dim(`→ ${statusText}`)}`);
+    }
+  }
+
+  // Quick actions
+  console.log();
+  console.log(chalk.bold("Quick Actions"));
+  
+  if (sources.length === 0) {
+    console.log(`  ${chalk.cyan("skills source add <url> --remote")}  Add a remote skill`);
+  }
+  
+  if (targets.length === 0) {
+    console.log(`  ${chalk.cyan("skills target add <name> <path>")}  Add a target`);
+  }
+  
+  if (sources.length > 0 && targets.length > 0) {
+    console.log(`  ${chalk.cyan("skills sync")}    Push skills to all targets`);
+    console.log(`  ${chalk.cyan("skills update")}  Refresh all sources`);
+  }
+  
+  console.log(`  ${chalk.cyan("skills doctor")}  Run diagnostics`);
+  console.log();
+}

package/src/commands/sync.ts

@@ -0,0 +1,72 @@
+import { cp, rm, mkdir } from "fs/promises";
+import { getTargets } from "../lib/config.ts";
+import { SKILLS_STORE } from "../lib/paths.ts";
+import { directoryExists } from "../lib/hash.ts";
+import type { Target } from "../types.ts";
+
+/**
+ * Sync a single target with the store
+ */
+export async function syncToTarget(target: Target): Promise<void> {
+  // Ensure target directory exists
+  await mkdir(target.path, { recursive: true });
+
+  // Check if store has content
+  const storeExists = await directoryExists(SKILLS_STORE);
+  if (!storeExists) {
+    console.log(`  ${target.name}: Store is empty, nothing to sync`);
+    return;
+  }
+
+  // Clear target and copy fresh from store
+  // We remove contents but keep the directory
+  const entries = await Bun.file(target.path).exists() ? [] : [];
+  
+  try {
+    // Remove existing contents
+    const { readdir } = await import("fs/promises");
+    const existingFiles = await readdir(target.path);
+    
+    for (const file of existingFiles) {
+      await rm(`${target.path}/${file}`, { recursive: true, force: true });
+    }
+  } catch {
+    // Directory might be empty or not exist
+  }
+
+  // Copy store contents to target
+  await cp(SKILLS_STORE, target.path, { recursive: true });
+  
+  console.log(`  ${target.name}: Synced`);
+}
+
+/**
+ * Sync all targets with the store
+ */
+export async function sync(): Promise<void> {
+  const targets = await getTargets();
+
+  if (targets.length === 0) {
+    console.log("No targets registered.");
+    console.log("Add a target with: skills target add <name> <path>");
+    return;
+  }
+
+  const storeExists = await directoryExists(SKILLS_STORE);
+  if (!storeExists) {
+    console.log("Store is empty. Add sources first with: skills source add <url> --remote");
+    return;
+  }
+
+  console.log("Syncing skills to all targets...\n");
+
+  for (const target of targets) {
+    try {
+      await syncToTarget(target);
+    } catch (error) {
+      console.error(`  ${target.name}: Failed - ${error instanceof Error ? error.message : error}`);
+    }
+  }
+
+  console.log("\nSync complete.");
+}

package/src/commands/target.ts

@@ -0,0 +1,97 @@
+import { resolve } from "path";
+import { mkdir } from "fs/promises";
+import chalk from "chalk";
+import Table from "cli-table3";
+import { addTarget, removeTarget, getTargets } from "../lib/config.ts";
+import { SKILLS_STORE } from "../lib/paths.ts";
+import { compareDirectories, directoryExists } from "../lib/hash.ts";
+import { syncToTarget } from "./sync.ts";
+
+/**
+ * Add a target directory
+ */
+export async function targetAdd(name: string, path: string): Promise<void> {
+  const absolutePath = resolve(path.replace(/^~/, process.env.HOME || process.env.USERPROFILE || ""));
+
+  console.log(`Adding target: ${name}`);
+  console.log(`Path: ${absolutePath}`);
+
+  // Create the target directory if it doesn't exist
+  await mkdir(absolutePath, { recursive: true });
+
+  // Add to config
+  await addTarget({
+    name,
+    path: absolutePath,
+  });
+
+  console.log(`Successfully registered target: ${name}`);
+
+  // Perform initial sync
+  console.log("Performing initial sync...");
+  await syncToTarget({ name, path: absolutePath });
+  
+  console.log(`Target "${name}" is now synced.`);
+}
+
+/**
+ * Remove a target by name
+ */
+export async function targetRemove(name: string): Promise<void> {
+  const removed = await removeTarget(name);
+  
+  if (!removed) {
+    throw new Error(`Target not found: ${name}`);
+  }
+
+  console.log(`Removed target: ${name}`);
+  console.log(`Note: Files at ${removed.path} were not deleted.`);
+}
+
+/**
+ * List all targets with sync status in a table format
+ */
+export async function targetList(): Promise<void> {
+  const targets = await getTargets();
+
+  if (targets.length === 0) {
+    console.log("No targets registered.");
+    console.log(`Add a target with: ${chalk.cyan("skills target add <name> <path>")}`);
+    return;
+  }
+
+  const table = new Table({
+    head: [
+      chalk.bold("Name"),
+      chalk.bold("Path"),
+      chalk.bold("Status"),
+    ],
+    style: {
+      head: [],
+      border: [],
+    },
+  });
+
+  for (const target of targets) {
+    const status = await compareDirectories(SKILLS_STORE, target.path);
+    let statusDisplay: string;
+    
+    if (status === "synced") {
+      statusDisplay = chalk.green("synced");
+    } else if (status === "not synced") {
+      statusDisplay = chalk.yellow("outdated");
+    } else {
+      statusDisplay = chalk.red("missing");
+    }
+    
+    table.push([
+      target.name,
+      target.path,
+      statusDisplay,
+    ]);
+  }
+
+  console.log();
+  console.log(table.toString());
+  console.log();
+}

package/src/commands/update.ts

@@ -0,0 +1,108 @@
+import { $ } from "bun";
+import { rm, cp } from "fs/promises";
+import { getSources } from "../lib/config.ts";
+import { getNamespacePath, parseGitUrl } from "../lib/paths.ts";
+import { directoryExists } from "../lib/hash.ts";
+
+/**
+ * Update all sources from their origins
+ */
+export async function update(): Promise<void> {
+  const sources = await getSources();
+
+  if (sources.length === 0) {
+    console.log("No sources registered.");
+    console.log("Add a source with: skills source add <url> --remote");
+    return;
+  }
+
+  console.log("Updating all sources...\n");
+
+  for (const source of sources) {
+    try {
+      if (source.type === "remote") {
+        await updateRemoteSource(source.namespace, source.url!);
+      } else {
+        await updateLocalSource(source.namespace, source.path!);
+      }
+    } catch (error) {
+      console.error(`  ${source.namespace}: Failed - ${error instanceof Error ? error.message : error}`);
+    }
+  }
+
+  console.log("\nUpdate complete.");
+  console.log("Run 'skills sync' to push changes to targets.");
+}
+
+/**
+ * Update a remote source by re-cloning
+ */
+async function updateRemoteSource(namespace: string, url: string): Promise<void> {
+  const targetPath = getNamespacePath(namespace);
+  const parsed = parseGitUrl(url);
+  
+  if (!parsed) {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  
+  const cloneUrl = parsed.cloneUrl;
+  const branch = parsed.branch || "main";
+  
+  console.log(`  ${namespace}: Updating from ${url}...`);
+
+  // Remove existing directory
+  await rm(targetPath, { recursive: true, force: true });
+
+  // Re-clone
+  try {
+    if (parsed.subdir) {
+      // Use sparse checkout for subdirectory
+      const tempPath = `${targetPath}_temp`;
+      
+      await $`git clone --filter=blob:none --no-checkout --depth 1 --branch ${branch} ${cloneUrl} ${tempPath}`.quiet();
+      await $`git -C ${tempPath} sparse-checkout init --cone`.quiet();
+      await $`git -C ${tempPath} sparse-checkout set ${parsed.subdir}`.quiet();
+      await $`git -C ${tempPath} checkout`.quiet();
+      
+      // Move subdirectory to target
+      const subdirFullPath = `${tempPath}/${parsed.subdir}`;
+      await cp(subdirFullPath, targetPath, { recursive: true });
+      
+      // Clean up
+      await rm(tempPath, { recursive: true, force: true });
+    } else {
+      await $`git clone --depth 1 --branch ${branch} ${cloneUrl} ${targetPath}`.quiet();
+      
+      // Remove .git directory
+      await rm(`${targetPath}/.git`, { recursive: true, force: true });
+    }
+    
+    console.log(`  ${namespace}: Updated`);
+  } catch (error) {
+    // Clean up on failure
+    await rm(`${targetPath}_temp`, { recursive: true, force: true });
+    throw new Error(`Failed to clone: ${error}`);
+  }
+}
+
+/**
+ * Update a local source by re-copying
+ */
+async function updateLocalSource(namespace: string, sourcePath: string): Promise<void> {
+  const targetPath = getNamespacePath(namespace);
+  
+  console.log(`  ${namespace}: Updating from ${sourcePath}...`);
+
+  // Check if source still exists
+  if (!(await directoryExists(sourcePath))) {
+    throw new Error(`Source folder no longer exists: ${sourcePath}`);
+  }
+
+  // Remove existing directory
+  await rm(targetPath, { recursive: true, force: true });
+
+  // Re-copy
+  await cp(sourcePath, targetPath, { recursive: true });
+  
+  console.log(`  ${namespace}: Updated`);
+}

package/src/lib/config.ts

@@ -0,0 +1,127 @@
+import { mkdir } from "fs/promises";
+import { SKILLS_ROOT, SKILLS_STORE, CONFIG_PATH } from "./paths.ts";
+import type { Config, Source, Target } from "../types.ts";
+
+const DEFAULT_CONFIG: Config = {
+  sources: [],
+  targets: [],
+};
+
+/**
+ * Ensure the skills directories exist
+ */
+export async function ensureDirectories(): Promise<void> {
+  await mkdir(SKILLS_ROOT, { recursive: true });
+  await mkdir(SKILLS_STORE, { recursive: true });
+}
+
+/**
+ * Read the config file, creating it if it doesn't exist
+ */
+export async function readConfig(): Promise<Config> {
+  await ensureDirectories();
+
+  const configFile = Bun.file(CONFIG_PATH);
+  
+  if (!(await configFile.exists())) {
+    await writeConfig(DEFAULT_CONFIG);
+    return DEFAULT_CONFIG;
+  }
+
+  try {
+    const content = await configFile.json();
+    return content as Config;
+  } catch {
+    // If config is corrupted, reset it
+    await writeConfig(DEFAULT_CONFIG);
+    return DEFAULT_CONFIG;
+  }
+}
+
+/**
+ * Write the config file
+ */
+export async function writeConfig(config: Config): Promise<void> {
+  await ensureDirectories();
+  await Bun.write(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Add a source to the config
+ */
+export async function addSource(source: Source): Promise<void> {
+  const config = await readConfig();
+  
+  // Check if namespace already exists
+  const existing = config.sources.find(s => s.namespace === source.namespace);
+  if (existing) {
+    throw new Error(`Source with namespace "${source.namespace}" already exists`);
+  }
+
+  config.sources.push(source);
+  await writeConfig(config);
+}
+
+/**
+ * Remove a source from the config
+ */
+export async function removeSource(namespace: string): Promise<Source | null> {
+  const config = await readConfig();
+  
+  const index = config.sources.findIndex(s => s.namespace === namespace);
+  if (index === -1) {
+    return null;
+  }
+
+  const [removed] = config.sources.splice(index, 1);
+  await writeConfig(config);
+  return removed;
+}
+
+/**
+ * Get all sources
+ */
+export async function getSources(): Promise<Source[]> {
+  const config = await readConfig();
+  return config.sources;
+}
+
+/**
+ * Add a target to the config
+ */
+export async function addTarget(target: Target): Promise<void> {
+  const config = await readConfig();
+  
+  // Check if name already exists
+  const existing = config.targets.find(t => t.name === target.name);
+  if (existing) {
+    throw new Error(`Target with name "${target.name}" already exists`);
+  }
+
+  config.targets.push(target);
+  await writeConfig(config);
+}
+
+/**
+ * Remove a target from the config
+ */
+export async function removeTarget(name: string): Promise<Target | null> {
+  const config = await readConfig();
+  
+  const index = config.targets.findIndex(t => t.name === name);
+  if (index === -1) {
+    return null;
+  }
+
+  const [removed] = config.targets.splice(index, 1);
+  await writeConfig(config);
+  return removed;
+}
+
+/**
+ * Get all targets
+ */
+export async function getTargets(): Promise<Target[]> {
+  const config = await readConfig();
+  return config.targets;
+}

package/src/lib/hash.ts

@@ -0,0 +1,80 @@
+import { readdir, stat } from "fs/promises";
+import { join } from "path";
+
+/**
+ * Recursively get all files in a directory with their content hashes
+ */
+async function getDirectoryFiles(dirPath: string, basePath: string = ""): Promise<Map<string, string>> {
+  const files = new Map<string, string>();
+  
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+      
+      if (entry.isDirectory()) {
+        const subFiles = await getDirectoryFiles(fullPath, relativePath);
+        for (const [path, hash] of subFiles) {
+          files.set(path, hash);
+        }
+      } else if (entry.isFile()) {
+        const file = Bun.file(fullPath);
+        const content = await file.arrayBuffer();
+        const hash = Bun.hash(content).toString(16);
+        files.set(relativePath, hash);
+      }
+    }
+  } catch {
+    // Directory doesn't exist or can't be read
+  }
+  
+  return files;
+}
+
+/**
+ * Compute a hash representing the entire directory structure and contents
+ */
+export async function hashDirectory(dirPath: string): Promise<string> {
+  const files = await getDirectoryFiles(dirPath);
+  
+  if (files.size === 0) {
+    return "empty";
+  }
+  
+  // Sort files by path for consistent hashing
+  const sortedEntries = Array.from(files.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+  
+  // Combine all file paths and hashes
+  const combined = sortedEntries.map(([path, hash]) => `${path}:${hash}`).join("|");
+  
+  return Bun.hash(combined).toString(16);
+}
+
+/**
+ * Check if a directory exists and is not empty
+ */
+export async function directoryExists(dirPath: string): Promise<boolean> {
+  try {
+    const stats = await stat(dirPath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Compare two directories and return if they are in sync
+ */
+export async function compareDirectories(source: string, target: string): Promise<"synced" | "not synced" | "target missing"> {
+  const targetExists = await directoryExists(target);
+  if (!targetExists) {
+    return "target missing";
+  }
+  
+  const sourceHash = await hashDirectory(source);
+  const targetHash = await hashDirectory(target);
+  
+  return sourceHash === targetHash ? "synced" : "not synced";
+}