tenfold 0.1.0

package/dist/chunk-C53TSGQL.js

@@ -0,0 +1,2814 @@
+// src/index.ts
+import { Command as Command7 } from "commander";
+
+// src/ui/banner.ts
+import figlet from "figlet";
+
+// src/ui/theme.ts
+import chalk from "chalk";
+import gradientString from "gradient-string";
+var colors = {
+  primary: chalk.hex("#3b82f6"),
+  // Blue
+  secondary: chalk.hex("#60a5fa"),
+  // Light Blue
+  success: chalk.hex("#22c55e"),
+  // Green
+  warning: chalk.hex("#f59e0b"),
+  // Amber
+  error: chalk.hex("#ef4444"),
+  // Red
+  info: chalk.hex("#0ea5e9"),
+  // Sky
+  muted: chalk.dim,
+  highlight: chalk.cyan,
+  bold: chalk.bold,
+  underline: chalk.underline
+};
+var brandGradient = gradientString([
+  "#2563eb",
+  // Blue 600
+  "#3b82f6",
+  // Blue 500
+  "#60a5fa"
+  // Blue 400
+]);
+var typeColors = {
+  INSTRUCTION: chalk.hex("#3b82f6"),
+  // Blue
+  HOOK: chalk.hex("#f59e0b"),
+  // Amber
+  COMMAND: chalk.hex("#22c55e"),
+  // Green
+  MCP_SERVER: chalk.hex("#8b5cf6"),
+  // Violet
+  SKILL: chalk.hex("#ec4899"),
+  // Pink
+  AGENT: chalk.hex("#14b8a6")
+  // Teal
+};
+var statusColors = {
+  installed: colors.success,
+  available: colors.info,
+  outdated: colors.warning,
+  conflict: colors.error
+};
+var typeIcons = {
+  INSTRUCTION: "\u{1F4DD}",
+  // 📝
+  HOOK: "\u{1F527}",
+  // 🔧
+  COMMAND: "\u2318",
+  // ⌘
+  MCP_SERVER: "\u{1F5A5}",
+  // 🖥️
+  SKILL: "\u26A1",
+  // ⚡
+  AGENT: "\u{1F916}"
+  // 🤖
+};
+function success(text) {
+  return colors.success(text);
+}
+function muted(text) {
+  return colors.muted(text);
+}
+function highlight(text) {
+  return colors.highlight(text);
+}
+function bold(text) {
+  return colors.bold(text);
+}
+function formatInstalls(count) {
+  if (count < 1e3) return muted(`${count} installs`);
+  if (count < 1e6) return muted(`${(count / 1e3).toFixed(1)}k installs`);
+  return muted(`${(count / 1e6).toFixed(1)}M installs`);
+}
+
+// src/ui/banner.ts
+var BANNER_TEXT = "TENFOLD";
+function renderBanner() {
+  const ascii = figlet.textSync(BANNER_TEXT, {
+    font: "ANSI Shadow",
+    horizontalLayout: "default"
+  });
+  const gradientBanner = brandGradient(ascii);
+  const tagline = muted("  The package manager for Claude Code components\n");
+  return `
+${gradientBanner}
+${tagline}`;
+}
+function renderWelcome() {
+  return `
+${renderBanner()}
+  ${muted("Get started:")}
+    tenfold search "typescript"    Search for components
+    tenfold browse --type=hook     Browse by type
+    tenfold install <author/name>  Install a component
+
+  ${muted("Learn more:")}
+    tenfold --help                 Show all commands
+    https://tenfold.dev/docs       Documentation
+`;
+}
+
+// src/commands/search.ts
+import { Command } from "commander";
+
+// src/utils/errors.ts
+var TenfoldError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "TenfoldError";
+  }
+};
+var ApiError = class _ApiError extends TenfoldError {
+  constructor(status, message) {
+    super(`API Error (${status}): ${message}`, "API_ERROR");
+    this.status = status;
+    this.name = "ApiError";
+  }
+  static fromStatus(status, body) {
+    let message;
+    switch (status) {
+      case 400:
+        message = "Bad request. Check your input.";
+        break;
+      case 401:
+        message = "Authentication required. Run 'tenfold login' first.";
+        break;
+      case 403:
+        message = "Permission denied. You may not have access to this resource.";
+        break;
+      case 404:
+        message = "Not found. Check the author/slug spelling.";
+        break;
+      case 429:
+        message = "Rate limited. Please wait a moment and try again.";
+        break;
+      case 500:
+      case 502:
+      case 503:
+        message = "Server error. Please try again later.";
+        break;
+      default:
+        message = body ?? "An unexpected error occurred.";
+    }
+    return new _ApiError(status, message);
+  }
+};
+var NotFoundError = class extends TenfoldError {
+  constructor(resourceType, identifier) {
+    super(`${resourceType} not found: ${identifier}`, "NOT_FOUND");
+    this.resourceType = resourceType;
+    this.identifier = identifier;
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends TenfoldError {
+  constructor(conflicts) {
+    super(`${conflicts.length} conflict(s) detected`, "CONFLICT");
+    this.conflicts = conflicts;
+    this.name = "ConflictError";
+  }
+};
+var AuthRequiredError = class extends TenfoldError {
+  constructor(operation) {
+    super(
+      `Authentication required for: ${operation}. Run 'tenfold login' first.`,
+      "AUTH_REQUIRED"
+    );
+    this.operation = operation;
+    this.name = "AuthRequiredError";
+  }
+};
+var ConfigError = class extends TenfoldError {
+  constructor(filePath, message) {
+    super(`Config error in ${filePath}: ${message}`, "CONFIG_ERROR");
+    this.filePath = filePath;
+    this.name = "ConfigError";
+  }
+};
+var ValidationError = class extends TenfoldError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+var NetworkError = class extends TenfoldError {
+  constructor(message) {
+    super(message, "NETWORK_ERROR");
+    this.name = "NetworkError";
+  }
+};
+function formatError(error) {
+  if (error instanceof ApiError) {
+    return error.message;
+  }
+  if (error instanceof NotFoundError) {
+    return error.message;
+  }
+  if (error instanceof ConflictError) {
+    const conflicts = error.conflicts.map(
+      (c) => `  - ${c.type}: ${c.existing.source} vs ${c.incoming.source}`
+    ).join("\n");
+    return `Conflicts detected:
+${conflicts}
+Use --force to override.`;
+  }
+  if (error instanceof AuthRequiredError) {
+    return error.message;
+  }
+  if (error instanceof ConfigError) {
+    return error.message;
+  }
+  if (error instanceof ValidationError) {
+    return error.message;
+  }
+  if (error instanceof NetworkError) {
+    return `Network error: ${error.message}. Check your internet connection.`;
+  }
+  if (error instanceof TenfoldError) {
+    return error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "An unexpected error occurred.";
+}
+function isRetryable(error) {
+  if (error instanceof ApiError) {
+    return [429, 500, 502, 503, 504].includes(error.status);
+  }
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  return false;
+}
+
+// src/api/client.ts
+var DEFAULT_BASE_URL = process.env.TENFOLD_API_URL ?? "http://localhost:3000";
+var DEFAULT_TIMEOUT = 3e4;
+var MAX_RETRIES = 3;
+var RETRY_DELAY = 1e3;
+var TenfoldApiClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  }
+  // Set API key (for authenticated operations)
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  // Core request method
+  async request(router, procedure, input2, options = {}) {
+    const isQuery = options.method !== "POST";
+    const url = new URL(`/api/trpc/${router}.${procedure}`, this.baseUrl);
+    if (isQuery && input2 !== void 0) {
+      url.searchParams.set("input", JSON.stringify({ json: input2 }));
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "tenfold-cli/0.1.0"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url.toString(), {
+        method: isQuery ? "GET" : "POST",
+        headers,
+        signal: controller.signal,
+        ...input2 !== void 0 && !isQuery && { body: JSON.stringify({ json: input2 }) }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        if (options.retry !== false && isRetryable(ApiError.fromStatus(response.status))) {
+          return this.retryRequest(router, procedure, input2, options);
+        }
+        throw ApiError.fromStatus(response.status, body);
+      }
+      const data = await response.json();
+      if (data.result?.data?.json !== void 0) {
+        return data.result.data.json;
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ApiError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new NetworkError("Request timed out");
+        }
+        throw new NetworkError(error.message);
+      }
+      throw new NetworkError("Unknown network error");
+    }
+  }
+  // Retry with exponential backoff
+  async retryRequest(router, procedure, input2, options = {}, attempt = 1) {
+    if (attempt > MAX_RETRIES) {
+      throw new NetworkError(`Failed after ${MAX_RETRIES} retries`);
+    }
+    await new Promise(
+      (resolve) => setTimeout(resolve, RETRY_DELAY * Math.pow(2, attempt - 1))
+    );
+    return this.request(router, procedure, input2, {
+      ...options,
+      retry: attempt < MAX_RETRIES
+    });
+  }
+  // ============================================
+  // Component Operations
+  // ============================================
+  async searchComponents(query, limit = 10) {
+    const result = await this.request(
+      "component",
+      "search",
+      { query, limit }
+    );
+    return result ?? [];
+  }
+  async getComponent(slug) {
+    const result = await this.request(
+      "component",
+      "get",
+      { slug }
+    );
+    if (!result) {
+      throw new NotFoundError("Component", slug);
+    }
+    return result;
+  }
+  async getComponentVersion(componentId, version) {
+    const result = await this.request(
+      "component",
+      "getVersion",
+      { componentId, version }
+    );
+    if (!result) {
+      throw new NotFoundError("Component version", `${componentId}@${version}`);
+    }
+    return result;
+  }
+  async getAttribution(versionId) {
+    return this.request("component", "getAttribution", {
+      versionId
+    });
+  }
+  async listComponents(input2 = {}) {
+    return this.request("component", "list", input2);
+  }
+  async getFeaturedComponents(limit = 10) {
+    const result = await this.request(
+      "component",
+      "featured",
+      { limit }
+    );
+    return result ?? [];
+  }
+  async getTrendingComponents(limit = 10) {
+    const result = await this.request(
+      "component",
+      "trending",
+      { limit }
+    );
+    return result ?? [];
+  }
+  // ============================================
+  // Bundle Operations
+  // ============================================
+  async searchBundles(query, limit = 10) {
+    const result = await this.request(
+      "bundle",
+      "search",
+      { query, limit }
+    );
+    return result ?? [];
+  }
+  async getBundle(slug) {
+    const result = await this.request("bundle", "get", {
+      slug
+    });
+    if (!result) {
+      throw new NotFoundError("Bundle", slug);
+    }
+    return result;
+  }
+  async listBundles(input2 = {}) {
+    return this.request("bundle", "list", input2);
+  }
+  // ============================================
+  // Category Operations
+  // ============================================
+  async listCategories() {
+    const result = await this.request(
+      "category",
+      "list",
+      {}
+    );
+    return result ?? [];
+  }
+  // ============================================
+  // Installation Tracking
+  // ============================================
+  async trackComponentInstall(componentSlug, versionId) {
+    await this.request(
+      "componentInstall",
+      "trackComponent",
+      { componentSlug, versionId },
+      { method: "POST" }
+    );
+  }
+  async trackBundleInstall(bundleSlug) {
+    await this.request(
+      "componentInstall",
+      "trackBundle",
+      { bundleSlug },
+      { method: "POST" }
+    );
+  }
+  // ============================================
+  // Authenticated Operations
+  // ============================================
+  async forkComponent(input2) {
+    if (!this.apiKey) {
+      throw new ApiError(401, "Authentication required for fork operation");
+    }
+    return this.request("component", "fork", input2, {
+      method: "POST"
+    });
+  }
+};
+var _client = null;
+function getApiClient(options) {
+  if (!_client || options) {
+    _client = new TenfoldApiClient(options);
+  }
+  return _client;
+}
+
+// src/ui/spinner.ts
+import ora from "ora";
+function createSpinner(text, options) {
+  return ora({
+    text,
+    color: options?.color ?? "cyan",
+    spinner: "dots"
+  });
+}
+function startSpinner(text, options) {
+  const spinner = createSpinner(text, options);
+  return spinner.start();
+}
+
+// src/ui/table.ts
+import Table from "cli-table3";
+var tableStyle = {
+  head: ["cyan"],
+  border: ["dim"]
+};
+var tableChars = {
+  top: "\u2500",
+  "top-mid": "\u252C",
+  "top-left": "\u250C",
+  "top-right": "\u2510",
+  bottom: "\u2500",
+  "bottom-mid": "\u2534",
+  "bottom-left": "\u2514",
+  "bottom-right": "\u2518",
+  left: "\u2502",
+  "left-mid": "\u251C",
+  mid: "\u2500",
+  "mid-mid": "\u253C",
+  right: "\u2502",
+  "right-mid": "\u2524",
+  middle: "\u2502"
+};
+function searchResultsTable(components) {
+  const table = new Table({
+    head: ["", "Component", "Type", "Description", "Installs"],
+    style: tableStyle,
+    chars: tableChars,
+    colWidths: [3, 26, 13, 35, 10],
+    wordWrap: true
+  });
+  for (const component of components) {
+    const icon = typeIcons[component.type] || "\u{1F4E6}";
+    const typeColor = typeColors[component.type] || colors.muted;
+    const [author, name] = component.slug.split("/");
+    table.push([
+      icon,
+      `${muted(author + "/")}${highlight(name || "")}`,
+      typeColor(component.type),
+      component.description.slice(0, 50) + (component.description.length > 50 ? "..." : ""),
+      formatInstalls(component.installCount)
+    ]);
+  }
+  return table.toString();
+}
+function browseResultsTable(components) {
+  const table = new Table({
+    head: ["Component", "Author", "Description", "Installs"],
+    style: tableStyle,
+    chars: tableChars,
+    colWidths: [25, 15, 40, 10],
+    wordWrap: true
+  });
+  for (const component of components) {
+    table.push([
+      highlight(component.slug.split("/")[1] || component.slug),
+      muted(`@${component.author.name}`),
+      component.description.slice(0, 55) + (component.description.length > 55 ? "..." : ""),
+      formatInstalls(component.installCount)
+    ]);
+  }
+  return table.toString();
+}
+function installedTable(components) {
+  const table = new Table({
+    head: ["Component", "Type", "Version", "Installed"],
+    style: tableStyle,
+    chars: tableChars,
+    colWidths: [30, 13, 12, 15]
+  });
+  for (const component of components) {
+    const icon = typeIcons[component.type] || "\u{1F4E6}";
+    const typeColor = typeColors[component.type] || colors.muted;
+    table.push([
+      `${icon} ${highlight(component.slug)}`,
+      typeColor(component.type),
+      muted(`v${component.version}`),
+      muted(formatRelativeTime(component.installedAt))
+    ]);
+  }
+  return table.toString();
+}
+function bundleItemsTable(bundle) {
+  const table = new Table({
+    head: ["", "Component", "Type", "Author"],
+    style: tableStyle,
+    chars: tableChars,
+    colWidths: [3, 30, 13, 15]
+  });
+  for (const item of bundle.items) {
+    const component = item.componentVersion.component;
+    const icon = typeIcons[component.type] || "\u{1F4E6}";
+    const typeColor = typeColors[component.type] || colors.muted;
+    table.push([
+      icon,
+      highlight(component.slug),
+      typeColor(component.type),
+      muted(`@${component.author.name}`)
+    ]);
+  }
+  return table.toString();
+}
+function installResultTable(results) {
+  const table = new Table({
+    head: ["Component", "Type", "Status"],
+    style: tableStyle,
+    chars: tableChars,
+    colWidths: [30, 13, 12]
+  });
+  for (const result of results) {
+    const icon = typeIcons[result.type] || "\u{1F4E6}";
+    const typeColor = typeColors[result.type] || colors.muted;
+    const statusIcon = result.status === "Added" ? colors.success("\u2714") : result.status === "Skipped" ? colors.warning("\u25CB") : colors.error("\u2718");
+    table.push([
+      `${icon} ${highlight(result.component)}`,
+      typeColor(result.type),
+      `${statusIcon} ${result.status}`
+    ]);
+  }
+  return table.toString();
+}
+function attributionTable(attributions) {
+  const table = new Table({
+    style: tableStyle,
+    chars: tableChars,
+    colWidths: [20, 10]
+  });
+  for (const attr of attributions) {
+    table.push([muted(`@${attr.authorName}`), `${attr.percentage.toFixed(0)}%`]);
+  }
+  return table.toString();
+}
+function formatRelativeTime(date) {
+  const d = new Date(date);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - d.getTime();
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays === 0) return "today";
+  if (diffDays === 1) return "yesterday";
+  if (diffDays < 7) return `${diffDays}d ago`;
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)}w ago`;
+  if (diffDays < 365) return `${Math.floor(diffDays / 30)}mo ago`;
+  return `${Math.floor(diffDays / 365)}y ago`;
+}
+
+// src/commands/search.ts
+function createSearchCommand() {
+  return new Command("search").description("Search for components").argument("<query>", "Search query").option("-t, --type <type>", "Filter by type (hook, skill, mcp_server, etc.)").option("-l, --limit <n>", "Number of results", "10").action(async (query, options) => {
+    const api = getApiClient();
+    const spinner = startSpinner(`Searching for "${query}"...`);
+    try {
+      const limit = parseInt(options.limit, 10);
+      const results = await api.searchComponents(query, limit);
+      spinner.stop();
+      if (results.length === 0) {
+        console.log(muted("\n  No results found.\n"));
+        console.log(muted("  Try a different search term or browse by type:"));
+        console.log(muted("    tenfold browse --type=hook\n"));
+        return;
+      }
+      console.log(bold(`
+  \u{1F50D} Results for "${query}"
+`));
+      console.log(searchResultsTable(results));
+      console.log();
+      if (results.length >= limit) {
+        console.log(
+          muted(`  Showing first ${limit} results. Use --limit to see more.
+`)
+        );
+      }
+    } catch (error) {
+      spinner.fail("Search failed");
+      console.error(colors.error(`
+  ${formatError(error)}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/browse.ts
+import { Command as Command2 } from "commander";
+var VALID_TYPES = [
+  "instruction",
+  "hook",
+  "command",
+  "mcp_server",
+  "skill",
+  "agent"
+];
+function createBrowseCommand() {
+  return new Command2("browse").description("Browse components by type or category").option("-t, --type <type>", "Filter by type (hook, skill, mcp_server, etc.)").option("-c, --category <category>", "Filter by category").option("-l, --limit <n>", "Number of results", "20").option("--featured", "Show only featured components").action(
+    async (options) => {
+      const api = getApiClient();
+      if (options.type) {
+        const normalizedType = options.type.toLowerCase().replace("-", "_");
+        if (!VALID_TYPES.includes(normalizedType)) {
+          console.error(
+            colors.error(`
+  Invalid type: ${options.type}
+`)
+          );
+          console.log(muted("  Valid types:"));
+          for (const t of VALID_TYPES) {
+            const icon = typeIcons[t.toUpperCase()] || "\u{1F4E6}";
+            console.log(muted(`    ${icon} ${t}`));
+          }
+          console.log();
+          process.exit(1);
+        }
+      }
+      const spinner = startSpinner("Loading components...");
+      try {
+        const limit = parseInt(options.limit, 10);
+        const typeFilter = options.type?.toUpperCase().replace("-", "_");
+        const result = await api.listComponents({
+          limit,
+          type: typeFilter,
+          categorySlug: options.category,
+          featured: options.featured
+        });
+        spinner.stop();
+        if (result.components.length === 0) {
+          console.log(muted("\n  No components found.\n"));
+          return;
+        }
+        let header = "\n  ";
+        if (options.type) {
+          const icon = typeIcons[typeFilter || ""] || "\u{1F4E6}";
+          header += `${icon} ${bold(options.type.toUpperCase())} Components`;
+        } else if (options.category) {
+          header += `\u{1F4C1} ${bold(options.category)} Category`;
+        } else if (options.featured) {
+          header += `\u2B50 ${bold("Featured")} Components`;
+        } else {
+          header += bold("All Components");
+        }
+        console.log(header + "\n");
+        console.log(browseResultsTable(result.components));
+        console.log();
+        if (result.hasMore) {
+          console.log(
+            muted(
+              `  Showing ${result.components.length} of ${result.total}. Use --limit to see more.
+`
+            )
+          );
+        }
+      } catch (error) {
+        spinner.fail("Failed to load components");
+        console.error(colors.error(`
+  ${formatError(error)}
+`));
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/install.ts
+import { Command as Command3 } from "commander";
+import { Listr } from "listr2";
+
+// src/config/installed.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname } from "path";
+
+// src/types/config.ts
+import { z } from "zod";
+var TenfoldMetadataSchema = z.object({
+  componentId: z.string(),
+  versionId: z.string(),
+  version: z.string(),
+  author: z.string(),
+  slug: z.string(),
+  installedAt: z.string()
+});
+var TargetFileSchema = z.object({
+  type: z.enum([
+    "claude_md",
+    "settings_json",
+    "mcp_json",
+    "skill_dir",
+    "command_file"
+  ]),
+  path: z.string(),
+  section: z.string().optional(),
+  key: z.string().optional()
+});
+var InstalledComponentSchema = z.object({
+  componentId: z.string(),
+  versionId: z.string(),
+  author: z.string(),
+  slug: z.string(),
+  type: z.enum([
+    "INSTRUCTION",
+    "HOOK",
+    "COMMAND",
+    "MCP_SERVER",
+    "SKILL",
+    "AGENT"
+  ]),
+  version: z.string(),
+  installedAt: z.string(),
+  updatedAt: z.string().optional(),
+  targetFiles: z.array(TargetFileSchema),
+  attribution: z.array(
+    z.object({
+      authorId: z.string(),
+      authorName: z.string(),
+      percentage: z.number()
+    })
+  ).optional()
+});
+var InstalledManifestSchema = z.object({
+  version: z.literal("1.0.0"),
+  components: z.array(InstalledComponentSchema),
+  lastUpdatedAt: z.string()
+});
+var HookDefinitionSchema = z.object({
+  type: z.literal("command"),
+  command: z.string()
+});
+var HookEntrySchema = z.object({
+  matcher: z.string(),
+  hooks: z.array(HookDefinitionSchema),
+  _tenfold: TenfoldMetadataSchema.optional()
+});
+var ClaudeSettingsSchema = z.object({
+  hooks: z.object({
+    PreToolUse: z.array(HookEntrySchema).optional(),
+    PostToolUse: z.array(HookEntrySchema).optional(),
+    Stop: z.array(HookEntrySchema).optional(),
+    Start: z.array(HookEntrySchema).optional(),
+    Subagent: z.array(HookEntrySchema).optional()
+  }).optional()
+});
+var McpServerEntrySchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string()).optional(),
+  _tenfold: TenfoldMetadataSchema.optional()
+});
+var McpConfigSchema = z.object({
+  mcpServers: z.record(McpServerEntrySchema).optional()
+});
+var CredentialsSchema = z.object({
+  apiKey: z.string().optional(),
+  userId: z.string().optional(),
+  createdAt: z.string().optional()
+});
+function createEmptyManifest() {
+  return {
+    version: "1.0.0",
+    components: [],
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function getHomeDir() {
+  return homedir();
+}
+function getClaudeDir() {
+  return join(getHomeDir(), ".claude");
+}
+function getTenfoldDir() {
+  return join(getHomeDir(), ".tenfold");
+}
+function getClaudeMdPath() {
+  return join(getClaudeDir(), "CLAUDE.md");
+}
+function getSettingsPath() {
+  return join(getClaudeDir(), "settings.json");
+}
+function getCommandsDir() {
+  return join(getClaudeDir(), "commands");
+}
+function getPluginsDir() {
+  return join(getClaudeDir(), "plugins");
+}
+function getMcpConfigPath() {
+  return join(getHomeDir(), ".mcp.json");
+}
+function getInstalledManifestPath() {
+  return join(getTenfoldDir(), "installed.json");
+}
+function isValidSlug(slug) {
+  const slugRegex = /^[a-z0-9_-]+\/[a-z0-9_-]+$/i;
+  return slugRegex.test(slug);
+}
+
+// src/config/installed.ts
+var InstalledManager = class {
+  manifestPath;
+  manifest = null;
+  constructor(manifestPath) {
+    this.manifestPath = manifestPath ?? getInstalledManifestPath();
+  }
+  // Load manifest from disk
+  async load() {
+    if (this.manifest) {
+      return this.manifest;
+    }
+    if (!existsSync(this.manifestPath)) {
+      this.manifest = createEmptyManifest();
+      return this.manifest;
+    }
+    try {
+      const content = await readFile(this.manifestPath, "utf-8");
+      const parsed = JSON.parse(content);
+      const validated = InstalledManifestSchema.parse(parsed);
+      this.manifest = validated;
+      return validated;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new ConfigError(this.manifestPath, "Invalid JSON");
+      }
+      throw new ConfigError(
+        this.manifestPath,
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  // Save manifest to disk
+  async save() {
+    if (!this.manifest) {
+      return;
+    }
+    this.manifest.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const dir = dirname(this.manifestPath);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(
+      this.manifestPath,
+      JSON.stringify(this.manifest, null, 2),
+      "utf-8"
+    );
+  }
+  // Get all installed components
+  async getAll() {
+    const manifest = await this.load();
+    return manifest.components;
+  }
+  // Get installed component by slug
+  async get(slug) {
+    const manifest = await this.load();
+    return manifest.components.find((c) => c.slug === slug) ?? null;
+  }
+  // Check if component is installed
+  async isInstalled(slug) {
+    const component = await this.get(slug);
+    return component !== null;
+  }
+  // Get installed version
+  async getInstalledVersion(slug) {
+    const component = await this.get(slug);
+    return component?.version ?? null;
+  }
+  // Track a new installation
+  async track(component, targetFiles, attribution) {
+    const manifest = await this.load();
+    manifest.components = manifest.components.filter(
+      (c) => c.slug !== component.slug
+    );
+    manifest.components.push({
+      componentId: component.componentId,
+      versionId: component.versionId,
+      author: component.author,
+      slug: component.slug,
+      type: component.type,
+      version: component.version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetFiles,
+      attribution: attribution?.map((a) => ({
+        authorId: a.authorId,
+        authorName: a.authorName,
+        percentage: a.percentage
+      }))
+    });
+    await this.save();
+  }
+  // Update an existing installation
+  async update(slug, newVersion, targetFiles) {
+    const manifest = await this.load();
+    const index = manifest.components.findIndex((c) => c.slug === slug);
+    if (index === -1) {
+      throw new ConfigError(this.manifestPath, `Component not installed: ${slug}`);
+    }
+    manifest.components[index] = {
+      ...manifest.components[index],
+      versionId: newVersion.versionId,
+      version: newVersion.version,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetFiles
+    };
+    await this.save();
+  }
+  // Remove an installation
+  async remove(slug) {
+    const manifest = await this.load();
+    const index = manifest.components.findIndex((c) => c.slug === slug);
+    if (index === -1) {
+      return null;
+    }
+    const [removed] = manifest.components.splice(index, 1);
+    await this.save();
+    return removed ?? null;
+  }
+  // Get components by type
+  async getByType(type) {
+    const manifest = await this.load();
+    return manifest.components.filter((c) => c.type === type);
+  }
+  // Get components that need updates (compare with latest versions)
+  async getOutdated(latestVersions) {
+    const manifest = await this.load();
+    return manifest.components.filter((c) => {
+      const latest = latestVersions.get(c.slug);
+      return latest && latest !== c.version;
+    });
+  }
+  // Clear all installed components (for testing)
+  async clear() {
+    this.manifest = createEmptyManifest();
+    await this.save();
+  }
+};
+var _manager = null;
+function getInstalledManager() {
+  if (!_manager) {
+    _manager = new InstalledManager();
+  }
+  return _manager;
+}
+
+// src/config/settings.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var SettingsManager = class {
+  settingsPath;
+  settings = null;
+  constructor(settingsPath) {
+    this.settingsPath = settingsPath ?? getSettingsPath();
+  }
+  // Load settings from disk
+  async load() {
+    if (this.settings) {
+      return this.settings;
+    }
+    if (!existsSync2(this.settingsPath)) {
+      this.settings = { hooks: {} };
+      return this.settings;
+    }
+    try {
+      const content = await readFile2(this.settingsPath, "utf-8");
+      if (!content.trim()) {
+        this.settings = { hooks: {} };
+        return this.settings;
+      }
+      this.settings = JSON.parse(content);
+      return this.settings;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new ConfigError(this.settingsPath, "Invalid JSON");
+      }
+      throw new ConfigError(
+        this.settingsPath,
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  // Save settings to disk
+  async save() {
+    if (!this.settings) {
+      return;
+    }
+    const dir = dirname2(this.settingsPath);
+    if (!existsSync2(dir)) {
+      await mkdir2(dir, { recursive: true });
+    }
+    await writeFile2(
+      this.settingsPath,
+      JSON.stringify(this.settings, null, 2),
+      "utf-8"
+    );
+  }
+  // Install a hook
+  async installHook(hookContent, metadata) {
+    const settings = await this.load();
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
+    const event = hookContent.event;
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = [];
+    }
+    const hookEntry = {
+      matcher: hookContent.matcher || "*",
+      hooks: [
+        {
+          type: "command",
+          command: `tenfold run-hook ${metadata.slug}`
+        }
+      ],
+      _tenfold: metadata
+    };
+    settings.hooks[event].push(hookEntry);
+    await this.save();
+    return {
+      type: "settings_json",
+      path: this.settingsPath,
+      key: `hooks.${event}`
+    };
+  }
+  // Uninstall a hook by slug
+  async uninstallHook(slug) {
+    const settings = await this.load();
+    if (!settings.hooks) {
+      return false;
+    }
+    let removed = false;
+    for (const event of Object.keys(settings.hooks)) {
+      const hooks = settings.hooks[event];
+      if (!hooks) continue;
+      const initialLength = hooks.length;
+      settings.hooks[event] = hooks.filter(
+        (h) => h._tenfold?.slug !== slug
+      );
+      if (settings.hooks[event].length < initialLength) {
+        removed = true;
+      }
+      if (settings.hooks[event].length === 0) {
+        delete settings.hooks[event];
+      }
+    }
+    if (removed) {
+      await this.save();
+    }
+    return removed;
+  }
+  // Check if a hook is installed
+  async isHookInstalled(slug) {
+    const settings = await this.load();
+    if (!settings.hooks) {
+      return false;
+    }
+    for (const event of Object.keys(settings.hooks)) {
+      const hooks = settings.hooks[event];
+      if (!hooks) continue;
+      if (hooks.some((h) => h._tenfold?.slug === slug)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // Get all installed hooks with tenfold metadata
+  async getInstalledHooks() {
+    const settings = await this.load();
+    const result = [];
+    if (!settings.hooks) {
+      return result;
+    }
+    for (const event of Object.keys(settings.hooks)) {
+      const hooks = settings.hooks[event];
+      if (!hooks) continue;
+      for (const entry of hooks) {
+        if (entry._tenfold) {
+          result.push({ event, entry });
+        }
+      }
+    }
+    return result;
+  }
+  // Check for hook conflicts (same event + matcher)
+  async detectConflict(hookContent) {
+    const settings = await this.load();
+    if (!settings.hooks) {
+      return null;
+    }
+    const event = hookContent.event;
+    const hooks = settings.hooks[event];
+    if (!hooks) {
+      return null;
+    }
+    const matcher = hookContent.matcher || "*";
+    for (const entry of hooks) {
+      if (entry.matcher === matcher && entry._tenfold) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  // Replace an existing hook
+  async replaceHook(oldSlug, hookContent, metadata) {
+    await this.uninstallHook(oldSlug);
+    return this.installHook(hookContent, metadata);
+  }
+  // Get hook definition for run-hook command
+  async getHookDefinition(slug) {
+    const settings = await this.load();
+    if (!settings.hooks) {
+      return null;
+    }
+    for (const event of Object.keys(settings.hooks)) {
+      const hooks = settings.hooks[event];
+      if (!hooks) continue;
+      const entry = hooks.find((h) => h._tenfold?.slug === slug);
+      if (entry && entry._tenfold) {
+        return {
+          name: slug.split("/")[1] || slug,
+          event,
+          matcher: entry.matcher,
+          command: entry.hooks[0]?.command || ""
+        };
+      }
+    }
+    return null;
+  }
+};
+var _manager2 = null;
+function getSettingsManager() {
+  if (!_manager2) {
+    _manager2 = new SettingsManager();
+  }
+  return _manager2;
+}
+
+// src/config/mcp.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+var McpManager = class {
+  configPath;
+  config = null;
+  constructor(configPath) {
+    this.configPath = configPath ?? getMcpConfigPath();
+  }
+  // Load config from disk
+  async load() {
+    if (this.config) {
+      return this.config;
+    }
+    if (!existsSync3(this.configPath)) {
+      this.config = { mcpServers: {} };
+      return this.config;
+    }
+    try {
+      const content = await readFile3(this.configPath, "utf-8");
+      if (!content.trim()) {
+        this.config = { mcpServers: {} };
+        return this.config;
+      }
+      this.config = JSON.parse(content);
+      return this.config;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new ConfigError(this.configPath, "Invalid JSON");
+      }
+      throw new ConfigError(
+        this.configPath,
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  // Save config to disk
+  async save() {
+    if (!this.config) {
+      return;
+    }
+    await writeFile3(
+      this.configPath,
+      JSON.stringify(this.config, null, 2),
+      "utf-8"
+    );
+  }
+  // Install an MCP server
+  async installServer(serverContent, metadata) {
+    const config = await this.load();
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+    const serverEntry = {
+      command: serverContent.command,
+      args: serverContent.args,
+      env: serverContent.env,
+      _tenfold: metadata
+    };
+    config.mcpServers[serverContent.name] = serverEntry;
+    await this.save();
+    return {
+      type: "mcp_json",
+      path: this.configPath,
+      key: `mcpServers.${serverContent.name}`
+    };
+  }
+  // Uninstall an MCP server by name
+  async uninstallServer(name) {
+    const config = await this.load();
+    if (!config.mcpServers || !config.mcpServers[name]) {
+      return false;
+    }
+    delete config.mcpServers[name];
+    await this.save();
+    return true;
+  }
+  // Uninstall by slug
+  async uninstallBySlug(slug) {
+    const config = await this.load();
+    if (!config.mcpServers) {
+      return false;
+    }
+    let removed = false;
+    for (const [name, entry] of Object.entries(config.mcpServers)) {
+      if (entry._tenfold?.slug === slug) {
+        delete config.mcpServers[name];
+        removed = true;
+      }
+    }
+    if (removed) {
+      await this.save();
+    }
+    return removed;
+  }
+  // Check if a server name exists
+  async hasServer(name) {
+    const config = await this.load();
+    return !!(config.mcpServers && config.mcpServers[name]);
+  }
+  // Check if a slug is installed
+  async isInstalled(slug) {
+    const config = await this.load();
+    if (!config.mcpServers) {
+      return false;
+    }
+    return Object.values(config.mcpServers).some(
+      (entry) => entry._tenfold?.slug === slug
+    );
+  }
+  // Get all installed MCP servers with tenfold metadata
+  async getInstalledServers() {
+    const config = await this.load();
+    const result = [];
+    if (!config.mcpServers) {
+      return result;
+    }
+    for (const [name, entry] of Object.entries(config.mcpServers)) {
+      if (entry._tenfold) {
+        result.push({ name, entry });
+      }
+    }
+    return result;
+  }
+  // Detect name conflict
+  async detectConflict(serverContent) {
+    const config = await this.load();
+    if (!config.mcpServers) {
+      return null;
+    }
+    const existing = config.mcpServers[serverContent.name];
+    if (existing) {
+      return existing;
+    }
+    return null;
+  }
+  // Replace an existing server
+  async replaceServer(name, serverContent, metadata) {
+    await this.uninstallServer(name);
+    return this.installServer(serverContent, metadata);
+  }
+  // Rename a server (for conflict resolution)
+  async renameServer(oldName, newName) {
+    const config = await this.load();
+    if (!config.mcpServers || !config.mcpServers[oldName]) {
+      return false;
+    }
+    const entry = config.mcpServers[oldName];
+    delete config.mcpServers[oldName];
+    config.mcpServers[newName] = entry;
+    await this.save();
+    return true;
+  }
+  // Get server entry by slug
+  async getBySlug(slug) {
+    const config = await this.load();
+    if (!config.mcpServers) {
+      return null;
+    }
+    for (const [name, entry] of Object.entries(config.mcpServers)) {
+      if (entry._tenfold?.slug === slug) {
+        return { name, entry };
+      }
+    }
+    return null;
+  }
+};
+var _manager3 = null;
+function getMcpManager() {
+  if (!_manager3) {
+    _manager3 = new McpManager();
+  }
+  return _manager3;
+}
+
+// src/config/claude-md.ts
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname3 } from "path";
+var SECTION_START = (slug) => `<!-- tenfold:start ${slug} -->`;
+var SECTION_END = (slug) => `<!-- tenfold:end ${slug} -->`;
+var ClaudeMdManager = class {
+  mdPath;
+  content = null;
+  constructor(mdPath) {
+    this.mdPath = mdPath ?? getClaudeMdPath();
+  }
+  // Load content from disk
+  async load() {
+    if (this.content !== null) {
+      return this.content;
+    }
+    if (!existsSync4(this.mdPath)) {
+      this.content = "";
+      return this.content;
+    }
+    try {
+      this.content = await readFile4(this.mdPath, "utf-8");
+      return this.content;
+    } catch (error) {
+      throw new ConfigError(
+        this.mdPath,
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  // Save content to disk
+  async save() {
+    if (this.content === null) {
+      return;
+    }
+    const dir = dirname3(this.mdPath);
+    if (!existsSync4(dir)) {
+      await mkdir3(dir, { recursive: true });
+    }
+    await writeFile4(this.mdPath, this.content, "utf-8");
+  }
+  // Install instruction content
+  async install(instructionContent, metadata, strategy = "section") {
+    let content = await this.load();
+    const paragraphs = instructionContent.paragraphs.join("\n\n");
+    const authorName = metadata.author;
+    switch (strategy) {
+      case "replace":
+        this.content = this.wrapWithSection(paragraphs, metadata.slug, authorName);
+        break;
+      case "append":
+        if (content && !content.endsWith("\n\n")) {
+          content += content.endsWith("\n") ? "\n" : "\n\n";
+        }
+        this.content = content + this.wrapWithSection(paragraphs, metadata.slug, authorName);
+        break;
+      case "section":
+      default:
+        content = this.removeSection(content, metadata.slug);
+        if (content && !content.endsWith("\n\n")) {
+          content += content.endsWith("\n") ? "\n" : "\n\n";
+        }
+        this.content = content + this.wrapWithSection(paragraphs, metadata.slug, authorName);
+        break;
+    }
+    await this.save();
+    return {
+      type: "claude_md",
+      path: this.mdPath,
+      section: metadata.slug
+    };
+  }
+  // Uninstall by removing section
+  async uninstall(slug) {
+    const content = await this.load();
+    if (!this.hasSection(content, slug)) {
+      return false;
+    }
+    this.content = this.removeSection(content, slug);
+    await this.save();
+    return true;
+  }
+  // Check if a section exists
+  hasSection(content, slug) {
+    return content.includes(SECTION_START(slug)) && content.includes(SECTION_END(slug));
+  }
+  // Remove a section
+  removeSection(content, slug) {
+    const startMarker = SECTION_START(slug);
+    const endMarker = SECTION_END(slug);
+    const startIdx = content.indexOf(startMarker);
+    if (startIdx === -1) {
+      return content;
+    }
+    const endIdx = content.indexOf(endMarker);
+    if (endIdx === -1) {
+      return content;
+    }
+    const before = content.slice(0, startIdx);
+    let after = content.slice(endIdx + endMarker.length);
+    while (after.startsWith("\n")) {
+      after = after.slice(1);
+    }
+    return before.trimEnd() + (after ? "\n\n" + after : "");
+  }
+  // Wrap content with section markers
+  wrapWithSection(content, slug, authorName) {
+    const displayName = slug.split("/")[1] || slug;
+    return `${SECTION_START(slug)}
+## ${this.titleCase(displayName)} (by @${authorName})
+
+${content}
+
+${SECTION_END(slug)}`;
+  }
+  // Get all installed sections
+  async getInstalledSections() {
+    const content = await this.load();
+    const sections = [];
+    const regex = /<!-- tenfold:start ([^\s]+) -->/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      sections.push(match[1]);
+    }
+    return sections;
+  }
+  // Check if section exists (for conflict detection)
+  async detectConflict(slug) {
+    const content = await this.load();
+    return this.hasSection(content, slug);
+  }
+  // Get section content
+  async getSectionContent(slug) {
+    const content = await this.load();
+    const startMarker = SECTION_START(slug);
+    const endMarker = SECTION_END(slug);
+    const startIdx = content.indexOf(startMarker);
+    if (startIdx === -1) {
+      return null;
+    }
+    const endIdx = content.indexOf(endMarker);
+    if (endIdx === -1) {
+      return null;
+    }
+    return content.slice(startIdx + startMarker.length, endIdx).trim();
+  }
+  // Helper: title case
+  titleCase(str) {
+    return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+};
+var _manager4 = null;
+function getClaudeMdManager() {
+  if (!_manager4) {
+    _manager4 = new ClaudeMdManager();
+  }
+  return _manager4;
+}
+
+// src/config/commands.ts
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir4, unlink, readdir } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join2, basename } from "path";
+var FRONTMATTER_START = "---";
+var TENFOLD_MARKER = "_tenfold:";
+var CommandsManager = class {
+  commandsDir;
+  constructor(commandsDir) {
+    this.commandsDir = commandsDir ?? getCommandsDir();
+  }
+  // Ensure directory exists
+  async ensureDir() {
+    if (!existsSync5(this.commandsDir)) {
+      await mkdir4(this.commandsDir, { recursive: true });
+    }
+  }
+  // Install a command
+  async install(commandContent, metadata) {
+    await this.ensureDir();
+    const commandPath = join2(this.commandsDir, `${commandContent.name}.md`);
+    const frontmatter = [
+      FRONTMATTER_START,
+      `description: ${commandContent.description}`,
+      `${TENFOLD_MARKER} ${JSON.stringify(metadata)}`
+    ];
+    if (commandContent.arguments && commandContent.arguments.length > 0) {
+      frontmatter.push("arguments:");
+      for (const arg of commandContent.arguments) {
+        frontmatter.push(`  - name: ${arg.name}`);
+        frontmatter.push(`    type: ${arg.type}`);
+        frontmatter.push(`    required: ${arg.required}`);
+        if (arg.description) {
+          frontmatter.push(`    description: ${arg.description}`);
+        }
+      }
+    }
+    frontmatter.push(FRONTMATTER_START);
+    const content = frontmatter.join("\n") + "\n\n" + commandContent.content;
+    await writeFile5(commandPath, content, "utf-8");
+    return {
+      type: "command_file",
+      path: commandPath
+    };
+  }
+  // Uninstall a command by slug
+  async uninstall(slug) {
+    const installed = await this.getInstalledCommands();
+    const command = installed.find((c) => c.metadata?.slug === slug);
+    if (!command) {
+      return false;
+    }
+    const commandPath = join2(this.commandsDir, `${command.name}.md`);
+    if (existsSync5(commandPath)) {
+      await unlink(commandPath);
+      return true;
+    }
+    return false;
+  }
+  // Uninstall by command name
+  async uninstallByName(name) {
+    const commandPath = join2(this.commandsDir, `${name}.md`);
+    if (existsSync5(commandPath)) {
+      await unlink(commandPath);
+      return true;
+    }
+    return false;
+  }
+  // Check if a command name exists
+  async hasCommand(name) {
+    const commandPath = join2(this.commandsDir, `${name}.md`);
+    return existsSync5(commandPath);
+  }
+  // Check if a slug is installed
+  async isInstalled(slug) {
+    const installed = await this.getInstalledCommands();
+    return installed.some((c) => c.metadata?.slug === slug);
+  }
+  // Get all installed commands with tenfold metadata
+  async getInstalledCommands() {
+    if (!existsSync5(this.commandsDir)) {
+      return [];
+    }
+    const files = await readdir(this.commandsDir);
+    const result = [];
+    for (const file of files) {
+      if (!file.endsWith(".md")) continue;
+      const commandPath = join2(this.commandsDir, file);
+      const content = await readFile5(commandPath, "utf-8");
+      const metadata = this.extractMetadata(content);
+      result.push({
+        name: basename(file, ".md"),
+        path: commandPath,
+        metadata
+      });
+    }
+    return result;
+  }
+  // Extract tenfold metadata from file content
+  extractMetadata(content) {
+    const lines = content.split("\n");
+    let inFrontmatter = false;
+    for (const line of lines) {
+      if (line.trim() === FRONTMATTER_START) {
+        if (inFrontmatter) break;
+        inFrontmatter = true;
+        continue;
+      }
+      if (inFrontmatter && line.startsWith(TENFOLD_MARKER)) {
+        try {
+          const jsonStr = line.slice(TENFOLD_MARKER.length).trim();
+          return JSON.parse(jsonStr);
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  // Detect name conflict
+  async detectConflict(commandContent) {
+    const commandPath = join2(this.commandsDir, `${commandContent.name}.md`);
+    if (!existsSync5(commandPath)) {
+      return null;
+    }
+    const content = await readFile5(commandPath, "utf-8");
+    return this.extractMetadata(content);
+  }
+  // Replace an existing command
+  async replace(commandContent, metadata) {
+    await this.uninstallByName(commandContent.name);
+    return this.install(commandContent, metadata);
+  }
+  // Rename a command (for conflict resolution)
+  async rename(oldName, newName) {
+    const oldPath = join2(this.commandsDir, `${oldName}.md`);
+    const newPath = join2(this.commandsDir, `${newName}.md`);
+    if (!existsSync5(oldPath)) {
+      return false;
+    }
+    const content = await readFile5(oldPath, "utf-8");
+    await writeFile5(newPath, content, "utf-8");
+    await unlink(oldPath);
+    return true;
+  }
+};
+var _manager5 = null;
+function getCommandsManager() {
+  if (!_manager5) {
+    _manager5 = new CommandsManager();
+  }
+  return _manager5;
+}
+
+// src/config/skills.ts
+import { writeFile as writeFile6, mkdir as mkdir5, rm, readdir as readdir2, readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join3 } from "path";
+var METADATA_FILE = ".tenfold.json";
+var SkillsManager = class {
+  pluginsDir;
+  constructor(pluginsDir) {
+    this.pluginsDir = pluginsDir ?? getPluginsDir();
+  }
+  // Get skill directory for a slug
+  getSkillDirForSlug(slug) {
+    const dirName = slug.replace("/", "-");
+    return join3(this.pluginsDir, dirName, "skills");
+  }
+  // Install a skill
+  async installSkill(skillContent, metadata) {
+    const skillDir = this.getSkillDirForSlug(metadata.slug);
+    const skillPath = join3(skillDir, skillContent.name);
+    if (!existsSync6(skillPath)) {
+      await mkdir5(skillPath, { recursive: true });
+    }
+    const promptPath = join3(skillPath, "prompt.md");
+    await writeFile6(promptPath, skillContent.prompt, "utf-8");
+    if (skillContent.description) {
+      const descPath = join3(skillPath, "description.txt");
+      await writeFile6(descPath, skillContent.description, "utf-8");
+    }
+    const metadataPath = join3(skillPath, METADATA_FILE);
+    await writeFile6(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    return {
+      type: "skill_dir",
+      path: skillPath
+    };
+  }
+  // Install an agent (similar to skill but with system prompt)
+  async installAgent(agentContent, metadata) {
+    const agentDir = this.getSkillDirForSlug(metadata.slug);
+    const agentPath = join3(agentDir, agentContent.name);
+    if (!existsSync6(agentPath)) {
+      await mkdir5(agentPath, { recursive: true });
+    }
+    const promptPath = join3(agentPath, "system-prompt.md");
+    await writeFile6(promptPath, agentContent.systemPrompt, "utf-8");
+    if (agentContent.description) {
+      const descPath = join3(agentPath, "description.txt");
+      await writeFile6(descPath, agentContent.description, "utf-8");
+    }
+    if (agentContent.tools && agentContent.tools.length > 0) {
+      const toolsPath = join3(agentPath, "tools.json");
+      await writeFile6(
+        toolsPath,
+        JSON.stringify(agentContent.tools, null, 2),
+        "utf-8"
+      );
+    }
+    const metadataPath = join3(agentPath, METADATA_FILE);
+    await writeFile6(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    return {
+      type: "skill_dir",
+      path: agentPath
+    };
+  }
+  // Uninstall by slug (removes entire plugin directory)
+  async uninstall(slug) {
+    const dirName = slug.replace("/", "-");
+    const pluginDir = join3(this.pluginsDir, dirName);
+    if (!existsSync6(pluginDir)) {
+      return false;
+    }
+    await rm(pluginDir, { recursive: true, force: true });
+    return true;
+  }
+  // Check if a slug is installed
+  async isInstalled(slug) {
+    const dirName = slug.replace("/", "-");
+    const pluginDir = join3(this.pluginsDir, dirName);
+    return existsSync6(pluginDir);
+  }
+  // Get all installed skills/agents with metadata
+  async getInstalledSkills() {
+    if (!existsSync6(this.pluginsDir)) {
+      return [];
+    }
+    const result = [];
+    const pluginDirs = await readdir2(this.pluginsDir);
+    for (const dir of pluginDirs) {
+      const pluginPath = join3(this.pluginsDir, dir);
+      const skillsPath = join3(pluginPath, "skills");
+      if (!existsSync6(skillsPath)) continue;
+      const skillDirs = await readdir2(skillsPath);
+      for (const skillDir of skillDirs) {
+        const skillPath = join3(skillsPath, skillDir);
+        const metadataPath = join3(skillPath, METADATA_FILE);
+        let metadata = null;
+        if (existsSync6(metadataPath)) {
+          try {
+            const content = await readFile6(metadataPath, "utf-8");
+            metadata = JSON.parse(content);
+          } catch {
+          }
+        }
+        const hasSystemPrompt = existsSync6(join3(skillPath, "system-prompt.md"));
+        const type = hasSystemPrompt ? "agent" : "skill";
+        result.push({
+          slug: dir.replace("-", "/"),
+          path: skillPath,
+          metadata,
+          type
+        });
+      }
+    }
+    return result;
+  }
+  // Detect conflict (check if skill/agent name already exists)
+  async detectConflict(content, slug) {
+    const skillDir = this.getSkillDirForSlug(slug);
+    const skillPath = join3(skillDir, content.name);
+    const metadataPath = join3(skillPath, METADATA_FILE);
+    if (!existsSync6(metadataPath)) {
+      return null;
+    }
+    try {
+      const metadataContent = await readFile6(metadataPath, "utf-8");
+      return JSON.parse(metadataContent);
+    } catch {
+      return null;
+    }
+  }
+  // Replace existing skill/agent
+  async replace(content, metadata, type) {
+    const skillDir = this.getSkillDirForSlug(metadata.slug);
+    const skillPath = join3(skillDir, content.name);
+    if (existsSync6(skillPath)) {
+      await rm(skillPath, { recursive: true, force: true });
+    }
+    if (type === "agent") {
+      return this.installAgent(content, metadata);
+    }
+    return this.installSkill(content, metadata);
+  }
+};
+var _manager6 = null;
+function getSkillsManager() {
+  if (!_manager6) {
+    _manager6 = new SkillsManager();
+  }
+  return _manager6;
+}
+
+// src/config/manager.ts
+var ConfigManager = class {
+  installed;
+  settings;
+  mcp;
+  claudeMd;
+  commands;
+  skills;
+  constructor() {
+    this.installed = getInstalledManager();
+    this.settings = getSettingsManager();
+    this.mcp = getMcpManager();
+    this.claudeMd = getClaudeMdManager();
+    this.commands = getCommandsManager();
+    this.skills = getSkillsManager();
+  }
+  // Create metadata from component and version
+  createMetadata(component, version) {
+    return {
+      componentId: component.id,
+      versionId: version.id,
+      version: version.version,
+      author: component.author.name,
+      slug: `${component.author.githubUsername}/${component.slug}`,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // Detect conflicts for a component version
+  async detectConflicts(component, version) {
+    const conflicts = [];
+    const content = version.content;
+    const slug = `${component.author.githubUsername}/${component.slug}`;
+    switch (component.type) {
+      case "HOOK": {
+        const hookContent = content;
+        const existing = await this.settings.detectConflict(hookContent);
+        if (existing && existing._tenfold?.slug !== slug) {
+          conflicts.push({
+            type: "hook_duplicate",
+            severity: "blocking",
+            existing: {
+              source: existing._tenfold?.slug || "unknown",
+              version: existing._tenfold?.version || "unknown"
+            },
+            incoming: {
+              source: slug,
+              version: version.version
+            }
+          });
+        }
+        break;
+      }
+      case "MCP_SERVER": {
+        const mcpContent = content;
+        const existing = await this.mcp.detectConflict(mcpContent);
+        if (existing && existing._tenfold?.slug !== slug) {
+          conflicts.push({
+            type: "mcp_server_name",
+            severity: "blocking",
+            existing: {
+              source: existing._tenfold?.slug || "user-defined",
+              version: existing._tenfold?.version || "unknown"
+            },
+            incoming: {
+              source: slug,
+              version: version.version
+            }
+          });
+        }
+        break;
+      }
+      case "INSTRUCTION": {
+        const hasConflict = await this.claudeMd.detectConflict(slug);
+        if (hasConflict) {
+          conflicts.push({
+            type: "claude_md_section",
+            severity: "warning",
+            existing: {
+              source: slug,
+              version: "current"
+            },
+            incoming: {
+              source: slug,
+              version: version.version
+            }
+          });
+        }
+        break;
+      }
+      case "COMMAND": {
+        const cmdContent = content;
+        const existing = await this.commands.detectConflict(cmdContent);
+        if (existing && existing.slug !== slug) {
+          conflicts.push({
+            type: "command_slug",
+            severity: "blocking",
+            existing: {
+              source: existing.slug,
+              version: existing.version
+            },
+            incoming: {
+              source: slug,
+              version: version.version
+            }
+          });
+        }
+        break;
+      }
+      case "SKILL":
+      case "AGENT": {
+        const skillContent = content;
+        const existing = await this.skills.detectConflict(skillContent, slug);
+        if (existing && existing.slug !== slug) {
+          conflicts.push({
+            type: "command_slug",
+            // Reuse type for skills
+            severity: "blocking",
+            existing: {
+              source: existing.slug,
+              version: existing.version
+            },
+            incoming: {
+              source: slug,
+              version: version.version
+            }
+          });
+        }
+        break;
+      }
+    }
+    return conflicts;
+  }
+  // Install a component
+  async installComponent(component, version, options = {}) {
+    const metadata = this.createMetadata(component, version);
+    const slug = metadata.slug;
+    const content = version.content;
+    const targetFiles = [];
+    if (options.dryRun) {
+      return {
+        success: true,
+        component: {
+          slug,
+          type: component.type,
+          version: version.version,
+          author: component.author.name
+        },
+        targetFiles: []
+      };
+    }
+    switch (component.type) {
+      case "HOOK": {
+        const hookContent = content;
+        const target = await this.settings.installHook(hookContent, metadata);
+        targetFiles.push(target);
+        break;
+      }
+      case "MCP_SERVER": {
+        const mcpContent = content;
+        const target = await this.mcp.installServer(mcpContent, metadata);
+        targetFiles.push(target);
+        break;
+      }
+      case "INSTRUCTION": {
+        const instructionContent = content;
+        const target = await this.claudeMd.install(
+          instructionContent,
+          metadata,
+          options.claudeMdStrategy || "section"
+        );
+        targetFiles.push(target);
+        break;
+      }
+      case "COMMAND": {
+        const cmdContent = content;
+        const target = await this.commands.install(cmdContent, metadata);
+        targetFiles.push(target);
+        break;
+      }
+      case "SKILL": {
+        const skillContent = content;
+        const target = await this.skills.installSkill(skillContent, metadata);
+        targetFiles.push(target);
+        break;
+      }
+      case "AGENT": {
+        const agentContent = content;
+        const target = await this.skills.installAgent(agentContent, metadata);
+        targetFiles.push(target);
+        break;
+      }
+    }
+    await this.installed.track(
+      {
+        componentId: component.id,
+        versionId: version.id,
+        author: component.author.name,
+        slug,
+        type: component.type,
+        version: version.version
+      },
+      targetFiles,
+      version.attributionSnapshot?.attributions
+    );
+    return {
+      success: true,
+      component: {
+        slug,
+        type: component.type,
+        version: version.version,
+        author: component.author.name
+      },
+      targetFiles
+    };
+  }
+  // Uninstall a component
+  async uninstallComponent(slug) {
+    const installed = await this.installed.get(slug);
+    if (!installed) {
+      return false;
+    }
+    switch (installed.type) {
+      case "HOOK":
+        await this.settings.uninstallHook(slug);
+        break;
+      case "MCP_SERVER":
+        await this.mcp.uninstallBySlug(slug);
+        break;
+      case "INSTRUCTION":
+        await this.claudeMd.uninstall(slug);
+        break;
+      case "COMMAND":
+        await this.commands.uninstall(slug);
+        break;
+      case "SKILL":
+      case "AGENT":
+        await this.skills.uninstall(slug);
+        break;
+    }
+    await this.installed.remove(slug);
+    return true;
+  }
+  // Get all installed components
+  async getInstalledComponents() {
+    return this.installed.getAll();
+  }
+  // Check if component is installed
+  async isInstalled(slug) {
+    return this.installed.isInstalled(slug);
+  }
+  // Get installed version
+  async getInstalledVersion(slug) {
+    return this.installed.getInstalledVersion(slug);
+  }
+  // Get hook definition for run-hook command
+  async getHookDefinition(slug) {
+    return this.settings.getHookDefinition(slug);
+  }
+};
+var _manager7 = null;
+function getConfigManager() {
+  if (!_manager7) {
+    _manager7 = new ConfigManager();
+  }
+  return _manager7;
+}
+
+// src/conflict/detector.ts
+var ConflictDetector = class {
+  // Detect all conflicts for a component version
+  async detect(component, version) {
+    const configManager = getConfigManager();
+    const conflicts = await configManager.detectConflicts(component, version);
+    const blocking = conflicts.filter((c) => c.severity === "blocking");
+    const warnings = conflicts.filter((c) => c.severity === "warning");
+    return {
+      hasConflicts: conflicts.length > 0,
+      blocking,
+      warnings
+    };
+  }
+  // Check if any conflicts require user intervention
+  hasBlockingConflicts(result) {
+    return result.blocking.length > 0;
+  }
+  // Format conflict for display
+  formatConflict(conflict) {
+    const typeLabels = {
+      mcp_server_name: "MCP Server name collision",
+      hook_duplicate: "Hook event+matcher conflict",
+      command_slug: "Command name collision",
+      claude_md_section: "CLAUDE.md section exists"
+    };
+    return `${typeLabels[conflict.type] || conflict.type}: ${conflict.existing.source} vs ${conflict.incoming.source}`;
+  }
+};
+var _detector = null;
+function getConflictDetector() {
+  if (!_detector) {
+    _detector = new ConflictDetector();
+  }
+  return _detector;
+}
+
+// src/ui/prompt.ts
+import { select, confirm, input } from "@inquirer/prompts";
+async function confirmPrompt(message, defaultValue = false) {
+  return confirm({
+    message,
+    default: defaultValue
+  });
+}
+async function selectPrompt(message, choices) {
+  return select({
+    message,
+    choices: choices.map((c) => ({
+      name: c.name,
+      value: c.value,
+      description: c.description
+    }))
+  });
+}
+async function inputPrompt(message, options) {
+  return input({
+    message,
+    default: options?.default,
+    validate: options?.validate
+  });
+}
+async function conflictResolutionPrompt(existing, incoming) {
+  console.log(colors.warning("\n  \u26A0  Conflict detected!"));
+  console.log(muted(`  Current:  ${existing}`));
+  console.log(muted(`  Incoming: ${incoming}
+`));
+  return selectPrompt(
+    "How would you like to resolve this?",
+    [
+      { name: `Replace with ${incoming}`, value: "replace" },
+      { name: `Keep ${existing} (skip)`, value: "keep" },
+      { name: "Rename incoming", value: "rename" },
+      { name: "View diff", value: "diff" }
+    ]
+  );
+}
+async function claudeMdStrategyPrompt() {
+  return selectPrompt(
+    "How should CLAUDE.md content be added?",
+    [
+      {
+        name: "Append to existing CLAUDE.md",
+        value: "append",
+        description: "Add content at the end of the file"
+      },
+      {
+        name: "Replace existing CLAUDE.md",
+        value: "replace",
+        description: "Overwrite the entire file"
+      },
+      {
+        name: "Add as separate section with source marker",
+        value: "section",
+        description: "Add with markers for easy identification"
+      }
+    ]
+  );
+}
+async function installBundlePrompt(bundleName, itemCount) {
+  return confirmPrompt(
+    `Install all ${itemCount} components from ${bundleName}?`,
+    true
+  );
+}
+async function renamePrompt(currentName, suggestedName) {
+  return inputPrompt(`Enter new name (current: ${currentName}):`, {
+    default: suggestedName,
+    validate: (value) => {
+      if (!value || value.length < 1) {
+        return "Name cannot be empty";
+      }
+      if (!/^[a-z0-9_-]+$/i.test(value)) {
+        return "Name can only contain letters, numbers, hyphens, and underscores";
+      }
+      return true;
+    }
+  });
+}
+
+// src/ui/box.ts
+import boxen from "boxen";
+var defaultBoxOptions = {
+  padding: 1,
+  margin: { top: 1, bottom: 1, left: 2, right: 2 },
+  borderStyle: "round"
+};
+function installHeaderBox(component, version) {
+  const icon = typeIcons[component.type] || "\u{1F4E6}";
+  const content = [
+    `${icon} Installing: ${brandGradient(component.slug)} v${version.version}`,
+    colors.muted(`   Author: ${component.author.name} (@${component.author.githubUsername})`)
+  ].join("\n");
+  return boxen(content, {
+    ...defaultBoxOptions,
+    borderColor: "magenta"
+  });
+}
+function bundleInstallHeaderBox(bundle) {
+  const content = [
+    `\u{1F4E6} Installing bundle: ${brandGradient(bundle.slug)}`,
+    colors.muted(`   Author: ${bundle.author.name} (@${bundle.author.githubUsername})`)
+  ].join("\n");
+  return boxen(content, {
+    ...defaultBoxOptions,
+    borderColor: "magenta"
+  });
+}
+function conflictBox(existing, incoming) {
+  const content = [
+    colors.warning("\u26A0  Conflict detected!"),
+    "",
+    `Current:  ${existing.source} v${existing.version}`,
+    `Incoming: ${incoming.source} v${incoming.version}`
+  ].join("\n");
+  return boxen(content, {
+    ...defaultBoxOptions,
+    borderColor: "yellow"
+  });
+}
+
+// src/conflict/resolver.ts
+var ConflictResolver = class {
+  // Resolve a single conflict interactively
+  async resolve(conflict) {
+    console.log(
+      conflictBox(conflict.existing, conflict.incoming)
+    );
+    const resolution = await conflictResolutionPrompt(
+      `${conflict.existing.source} v${conflict.existing.version}`,
+      `${conflict.incoming.source} v${conflict.incoming.version}`
+    );
+    if (resolution === "diff") {
+      await this.showDiff(conflict);
+      return this.resolve(conflict);
+    }
+    if (resolution === "rename") {
+      const suggestedName = this.suggestRename(conflict);
+      const newName = await renamePrompt(
+        conflict.incoming.source.split("/")[1] || conflict.incoming.source,
+        suggestedName
+      );
+      return { conflict, resolution, newName };
+    }
+    return { conflict, resolution };
+  }
+  // Resolve all conflicts
+  async resolveAll(conflicts) {
+    const resolved = [];
+    for (const conflict of conflicts) {
+      const result = await this.resolve(conflict);
+      resolved.push(result);
+    }
+    return resolved;
+  }
+  // Show diff between existing and incoming
+  async showDiff(conflict) {
+    console.log(muted("\n  Diff view:"));
+    console.log(muted(`  - Current:  ${conflict.existing.source} v${conflict.existing.version}`));
+    console.log(muted(`  + Incoming: ${conflict.incoming.source} v${conflict.incoming.version}`));
+    console.log(muted("\n  (Detailed diff not yet implemented)\n"));
+  }
+  // Suggest a new name for rename resolution
+  suggestRename(conflict) {
+    const incomingName = conflict.incoming.source.split("/")[1] || conflict.incoming.source;
+    const author = conflict.incoming.source.split("/")[0] || "custom";
+    return `${incomingName}-${author}`;
+  }
+  // Check if resolution is to skip installation
+  isSkip(resolution) {
+    return resolution === "keep";
+  }
+  // Check if resolution is to replace
+  isReplace(resolution) {
+    return resolution === "replace";
+  }
+  // Check if resolution is to rename
+  isRename(resolution) {
+    return resolution === "rename";
+  }
+};
+var _resolver = null;
+function getConflictResolver() {
+  if (!_resolver) {
+    _resolver = new ConflictResolver();
+  }
+  return _resolver;
+}
+
+// src/ui/links.ts
+import terminalLink from "terminal-link";
+var BASE_URL = process.env.TENFOLD_WEB_URL ?? "https://tenfold.dev";
+function link(text, url) {
+  return terminalLink(text, url, {
+    fallback: (text2, url2) => `${text2} (${muted(url2)})`
+  });
+}
+function componentLink(slug) {
+  const url = `${BASE_URL}/components/${slug}`;
+  return link(colors.info("View online \u2192"), url);
+}
+function bundleLink(slug) {
+  const url = `${BASE_URL}/bundles/${slug}`;
+  return link(colors.info("View online \u2192"), url);
+}
+
+// src/commands/install.ts
+function createInstallCommand() {
+  return new Command3("install").description("Install a component or bundle").argument("<slug>", "Component or bundle to install (author/name)").option("-f, --force", "Override conflicts without prompting").option("--dry-run", "Show what would be installed without making changes").option("-v, --version <version>", "Install specific version").action(
+    async (slug, options) => {
+      if (!isValidSlug(slug)) {
+        console.error(
+          colors.error(
+            `
+  Invalid slug format: "${slug}". Expected "author/name".
+`
+          )
+        );
+        process.exit(1);
+      }
+      const api = getApiClient();
+      const configManager = getConfigManager();
+      const detector = getConflictDetector();
+      const resolver = getConflictResolver();
+      let isBundle = false;
+      let component = null;
+      let bundle = null;
+      try {
+        component = await api.getComponent(slug);
+      } catch (error) {
+        if (error instanceof NotFoundError) {
+          try {
+            bundle = await api.getBundle(slug);
+            isBundle = true;
+          } catch {
+            console.error(colors.error(`
+  Not found: ${slug}
+`));
+            const similar = await api.searchComponents(
+              slug.split("/")[1] || slug,
+              3
+            );
+            if (similar.length > 0) {
+              console.log(muted("  Did you mean:"));
+              for (const s of similar) {
+                console.log(muted(`    - ${s.author.githubUsername}/${s.slug}`));
+              }
+              console.log();
+            }
+            process.exit(1);
+          }
+        } else {
+          throw error;
+        }
+      }
+      if (isBundle && bundle) {
+        await installBundle(bundle, api, configManager, options);
+      } else if (component) {
+        await installComponent(
+          component,
+          api,
+          configManager,
+          detector,
+          resolver,
+          options
+        );
+      }
+    }
+  );
+}
+async function installComponent(component, api, configManager, detector, resolver, options) {
+  const version = component.versions[0];
+  if (!version) {
+    console.error(colors.error(`
+  No versions available for ${component.slug}
+`));
+    process.exit(1);
+  }
+  console.log(installHeaderBox(component, version));
+  let strategy = "section";
+  if (component.type === "INSTRUCTION" && !options.force) {
+    strategy = await claudeMdStrategyPrompt();
+  }
+  const tasks = new Listr(
+    [
+      {
+        title: "Checking for conflicts",
+        task: async (ctx) => {
+          const result = await detector.detect(component, version);
+          ctx.conflicts = result;
+          if (result.blocking.length > 0 && !options.force) {
+            throw new Error("CONFLICTS_DETECTED");
+          }
+        }
+      },
+      {
+        title: options.dryRun ? "Dry run - no changes made" : "Installing component",
+        skip: (ctx) => {
+          if (ctx.conflicts?.blocking.length && !options.force) {
+            return "Blocked by conflicts";
+          }
+          return false;
+        },
+        task: async (ctx) => {
+          if (options.dryRun) {
+            ctx.installed = false;
+            return;
+          }
+          const result = await configManager.installComponent(
+            component,
+            version,
+            { claudeMdStrategy: strategy }
+          );
+          ctx.installed = result.success;
+          ctx.results = [
+            {
+              component: component.slug,
+              type: component.type,
+              status: "Added"
+            }
+          ];
+        }
+      },
+      {
+        title: "Tracking installation",
+        skip: () => !!options.dryRun,
+        task: async () => {
+          try {
+            await api.trackComponentInstall(
+              `${component.author.githubUsername}/${component.slug}`,
+              version.id
+            );
+          } catch {
+          }
+        }
+      }
+    ],
+    {
+      exitOnError: false,
+      rendererOptions: {
+        collapseErrors: false
+      }
+    }
+  );
+  try {
+    const ctx = await tasks.run();
+    if (ctx.conflicts?.blocking.length && !options.force) {
+      console.log();
+      for (const conflict of ctx.conflicts.blocking) {
+        const resolved = await resolver.resolve(conflict);
+        if (resolver.isSkip(resolved.resolution)) {
+          console.log(muted(`  Skipped: ${component.slug}
+`));
+          return;
+        }
+        if (resolver.isReplace(resolved.resolution)) {
+          await configManager.uninstallComponent(conflict.existing.source);
+          const result = await configManager.installComponent(
+            component,
+            version,
+            { claudeMdStrategy: strategy }
+          );
+          ctx.installed = result.success;
+          ctx.results = [
+            {
+              component: component.slug,
+              type: component.type,
+              status: "Replaced"
+            }
+          ];
+        }
+      }
+    }
+    if (ctx.installed && ctx.results) {
+      console.log(installResultTable(ctx.results));
+      console.log();
+      const attribution = version.attributionSnapshot?.attributions;
+      if (attribution && attribution.length > 1) {
+        console.log(muted("  Attribution:"));
+        console.log(attributionTable(attribution));
+        console.log();
+      }
+      console.log(
+        `  ${componentLink(`${component.author.githubUsername}/${component.slug}`)}
+`
+      );
+    }
+  } catch (error) {
+    if (error.message !== "CONFLICTS_DETECTED") {
+      console.error(colors.error(`
+  ${formatError(error)}
+`));
+      process.exit(1);
+    }
+  }
+}
+async function installBundle(bundle, api, configManager, options) {
+  console.log(bundleInstallHeaderBox(bundle));
+  console.log(muted("  Components included:\n"));
+  console.log(bundleItemsTable(bundle));
+  console.log();
+  if (!options.force) {
+    const confirm2 = await installBundlePrompt(
+      bundle.displayName,
+      bundle.items.length
+    );
+    if (!confirm2) {
+      console.log(muted("\n  Installation cancelled.\n"));
+      return;
+    }
+  }
+  const results = [];
+  for (const item of bundle.items) {
+    const component = item.componentVersion.component;
+    const version = item.componentVersion;
+    try {
+      if (!options.dryRun) {
+        await configManager.installComponent(component, version);
+      }
+      results.push({
+        component: `${component.author.githubUsername}/${component.slug}`,
+        type: component.type,
+        status: options.dryRun ? "Would add" : "Added"
+      });
+    } catch {
+      results.push({
+        component: `${component.author.githubUsername}/${component.slug}`,
+        type: component.type,
+        status: "Failed"
+      });
+    }
+  }
+  if (!options.dryRun) {
+    try {
+      await api.trackBundleInstall(
+        `${bundle.author.githubUsername}/${bundle.slug}`
+      );
+    } catch {
+    }
+  }
+  console.log(success(`
+  ${options.dryRun ? "Would install" : "Installed"} bundle: ${bundle.slug}
+`));
+  console.log(installResultTable(results));
+  console.log();
+  console.log(
+    `  ${bundleLink(`${bundle.author.githubUsername}/${bundle.slug}`)}
+`
+  );
+}
+
+// src/commands/list.ts
+import { Command as Command4 } from "commander";
+function createListCommand() {
+  return new Command4("list").alias("ls").description("List installed components").option("-t, --type <type>", "Filter by type (hook, skill, mcp_server, etc.)").action(async (options) => {
+    const manager = getInstalledManager();
+    try {
+      let components = await manager.getAll();
+      if (options.type) {
+        const typeFilter = options.type.toUpperCase().replace("-", "_");
+        components = components.filter((c) => c.type === typeFilter);
+      }
+      if (components.length === 0) {
+        if (options.type) {
+          console.log(
+            muted(`
+  No ${options.type} components installed.
+`)
+          );
+        } else {
+          console.log(muted("\n  No components installed.\n"));
+          console.log(muted("  Get started:"));
+          console.log(muted("    tenfold search <query>"));
+          console.log(muted("    tenfold install <author>/<component>\n"));
+        }
+        return;
+      }
+      console.log(bold("\n  Installed Components\n"));
+      console.log(installedTable(components));
+      console.log();
+      console.log(muted(`  ${components.length} component(s) installed
+`));
+    } catch (error) {
+      console.error(colors.error(`
+  ${formatError(error)}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/uninstall.ts
+import { Command as Command5 } from "commander";
+function createUninstallCommand() {
+  return new Command5("uninstall").alias("rm").description("Uninstall a component").argument("<slug>", "Component to uninstall (author/name)").option("-f, --force", "Skip confirmation prompt").action(async (slug, options) => {
+    if (!isValidSlug(slug)) {
+      console.error(
+        colors.error(
+          `
+  Invalid slug format: "${slug}". Expected "author/name".
+`
+        )
+      );
+      process.exit(1);
+    }
+    const configManager = getConfigManager();
+    const isInstalled = await configManager.isInstalled(slug);
+    if (!isInstalled) {
+      console.log(muted(`
+  Component not installed: ${slug}
+`));
+      process.exit(1);
+    }
+    if (!options.force) {
+      const confirmed = await confirmPrompt(
+        `Uninstall ${slug}?`,
+        false
+      );
+      if (!confirmed) {
+        console.log(muted("\n  Cancelled.\n"));
+        return;
+      }
+    }
+    const spinner = startSpinner(`Uninstalling ${slug}...`);
+    try {
+      const removed = await configManager.uninstallComponent(slug);
+      if (removed) {
+        spinner.succeed(`Uninstalled ${slug}`);
+        console.log();
+      } else {
+        spinner.fail(`Failed to uninstall ${slug}`);
+        process.exit(1);
+      }
+    } catch (error) {
+      spinner.fail("Uninstall failed");
+      console.error(colors.error(`
+  ${formatError(error)}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/run-hook.ts
+import { Command as Command6 } from "commander";
+import { spawn } from "child_process";
+function createRunHookCommand() {
+  return new Command6("run-hook").description("Execute an installed hook").argument("<slug>", "Hook to execute (author/name)").option("--timeout <ms>", "Execution timeout in milliseconds", "30000").action(async (slug, options) => {
+    if (!isValidSlug(slug)) {
+      console.error(
+        colors.error(
+          `Invalid slug format: "${slug}". Expected "author/name".`
+        )
+      );
+      process.exit(1);
+    }
+    const configManager = getConfigManager();
+    const hookDef = await configManager.getHookDefinition(slug);
+    if (!hookDef) {
+      console.error(colors.error(`Hook not installed: ${slug}`));
+      console.error(muted(`Install it first: tenfold install ${slug}`));
+      process.exit(1);
+    }
+    const timeout = parseInt(options.timeout, 10);
+    const child = spawn(hookDef.command, [], {
+      stdio: "inherit",
+      shell: true,
+      timeout
+    });
+    child.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+    child.on("error", (error) => {
+      console.error(colors.error(`Hook execution failed: ${error.message}`));
+      process.exit(1);
+    });
+  });
+}
+
+// src/types/component.ts
+function isHookContent(content) {
+  return "event" in content && "command" in content;
+}
+function isMcpServerContent(content) {
+  return "command" in content && !("event" in content) && !("prompt" in content);
+}
+function isInstructionContent(content) {
+  return "paragraphs" in content;
+}
+function isCommandContent(content) {
+  return "content" in content && "name" in content && !("prompt" in content);
+}
+function isSkillContent(content) {
+  return "prompt" in content && !("systemPrompt" in content);
+}
+function isAgentContent(content) {
+  return "systemPrompt" in content;
+}
+var COMPONENT_ICONS = {
+  INSTRUCTION: "\u{1F4DD}",
+  HOOK: "\u{1F527}",
+  COMMAND: "\u2318",
+  MCP_SERVER: "\u{1F5A5}",
+  SKILL: "\u26A1",
+  AGENT: "\u{1F916}"
+};
+function getComponentIcon(type) {
+  return COMPONENT_ICONS[type] || "\u{1F4E6}";
+}
+
+// src/types/api.ts
+var DEFAULT_API_CONFIG = {
+  baseUrl: process.env.TENFOLD_API_URL ?? "https://api.tenfold.dev",
+  timeout: 3e4
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+function createProgram() {
+  const program = new Command7().name("tenfold").description("Package manager for Claude Code components").version(VERSION, "-V, --version", "Display version number");
+  program.addHelpText("beforeAll", renderBanner());
+  program.addCommand(createSearchCommand());
+  program.addCommand(createBrowseCommand());
+  program.addCommand(createInstallCommand());
+  program.addCommand(createListCommand());
+  program.addCommand(createUninstallCommand());
+  program.addCommand(createRunHookCommand());
+  program.action(() => {
+    console.log(renderWelcome());
+  });
+  return program;
+}
+
+export {
+  TenfoldApiClient,
+  getApiClient,
+  TenfoldMetadataSchema,
+  TargetFileSchema,
+  InstalledComponentSchema,
+  InstalledManifestSchema,
+  HookDefinitionSchema,
+  HookEntrySchema,
+  ClaudeSettingsSchema,
+  McpServerEntrySchema,
+  McpConfigSchema,
+  CredentialsSchema,
+  createEmptyManifest,
+  ConfigManager,
+  getConfigManager,
+  isHookContent,
+  isMcpServerContent,
+  isInstructionContent,
+  isCommandContent,
+  isSkillContent,
+  isAgentContent,
+  COMPONENT_ICONS,
+  getComponentIcon,
+  DEFAULT_API_CONFIG,
+  createProgram
+};