caik-cli 0.1.1 → 0.6.0

package/dist/chunk-DKZBQRR3.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import {
+  getConfigDir
+} from "./chunk-KYTHKH6V.js";
+
+// src/platform/registry.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "fs";
+import { join } from "path";
+var REGISTRY_VERSION = 1;
+function getRegistryPath() {
+  return join(getConfigDir(), "registry.json");
+}
+function emptyRegistry() {
+  return { version: REGISTRY_VERSION, entries: [] };
+}
+function readRegistry() {
+  const path = getRegistryPath();
+  if (!existsSync(path)) return emptyRegistry();
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.entries || !Array.isArray(parsed.entries)) return emptyRegistry();
+    return parsed;
+  } catch {
+    return emptyRegistry();
+  }
+}
+function writeRegistry(registry) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const path = getRegistryPath();
+  writeFileSync(path, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+}
+function upsertRegistryEntry(entry) {
+  const registry = readRegistry();
+  const idx = registry.entries.findIndex(
+    (e) => e.slug === entry.slug && e.platform === entry.platform
+  );
+  if (idx >= 0) {
+    registry.entries[idx] = entry;
+  } else {
+    registry.entries.push(entry);
+  }
+  writeRegistry(registry);
+}
+function removeRegistryEntry(slug, platform) {
+  const registry = readRegistry();
+  const idx = registry.entries.findIndex(
+    (e) => e.slug === slug && e.platform === platform
+  );
+  if (idx < 0) return null;
+  const [removed] = registry.entries.splice(idx, 1);
+  writeRegistry(registry);
+  return removed;
+}
+function findRegistryEntry(slug, platform) {
+  const registry = readRegistry();
+  return registry.entries.find(
+    (e) => e.slug === slug && (!platform || e.platform === platform)
+  ) ?? null;
+}
+function listRegistryEntries(platform) {
+  const registry = readRegistry();
+  if (!platform) return registry.entries;
+  return registry.entries.filter((e) => e.platform === platform);
+}
+function cleanupFiles(entry) {
+  const failed = [];
+  for (const file of entry.files) {
+    try {
+      if (existsSync(file)) {
+        unlinkSync(file);
+      }
+    } catch {
+      failed.push(file);
+    }
+  }
+  return failed;
+}
+
+export {
+  readRegistry,
+  writeRegistry,
+  upsertRegistryEntry,
+  removeRegistryEntry,
+  findRegistryEntry,
+  listRegistryEntries,
+  cleanupFiles
+};

package/dist/chunk-FLSHJZLC.js

@@ -0,0 +1,613 @@
+#!/usr/bin/env node
+import {
+  CaikError
+} from "./chunk-2YHUDOJL.js";
+
+// src/repo-installer.ts
+import { mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+// src/utils/github-fetch.ts
+var GITHUB_API = "https://api.github.com";
+var RAW_BASE = "https://raw.githubusercontent.com";
+function parseSource(input) {
+  let skill;
+  const atIdx = input.lastIndexOf("@");
+  if (atIdx > 0 && !input.slice(0, atIdx).includes("://")) {
+    skill = input.slice(atIdx + 1);
+    input = input.slice(0, atIdx);
+  } else if (atIdx > 0 && input.includes("://")) {
+    const urlWithoutProtocol = input.replace(/^https?:\/\//, "");
+    const urlAtIdx = urlWithoutProtocol.lastIndexOf("@");
+    if (urlAtIdx > 0) {
+      skill = urlWithoutProtocol.slice(urlAtIdx + 1);
+      input = input.slice(0, input.length - skill.length - 1);
+    }
+  }
+  if (input.includes("github.com")) {
+    const url = input.replace(/^https?:\/\//, "").replace(/\/$/, "");
+    const parts = url.replace("github.com/", "").split("/");
+    const owner = parts[0];
+    const repo = parts[1]?.replace(/\.git$/, "");
+    if (owner && repo) {
+      return { type: "github", owner, repo, skill };
+    }
+  }
+  if (/^[a-zA-Z0-9][a-zA-Z0-9_.-]*\/[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(input)) {
+    const [owner, repo] = input.split("/");
+    return { type: "github", owner, repo, skill };
+  }
+  return { type: "local", path: input, skill };
+}
+function getHeaders() {
+  const headers = {
+    Accept: "application/vnd.github.v3+json"
+  };
+  const token = process.env.GITHUB_TOKEN;
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return headers;
+}
+async function listContents(owner, repo, path = "") {
+  const url = path ? `${GITHUB_API}/repos/${owner}/${repo}/contents/${path}` : `${GITHUB_API}/repos/${owner}/${repo}/contents`;
+  const response = await fetch(url, { headers: getHeaders() });
+  if (response.status === 404) return null;
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (!Array.isArray(data)) return [data];
+  return data;
+}
+async function fetchRawFile(owner, repo, path, ref) {
+  if (ref) {
+    const refUrl = `${RAW_BASE}/${owner}/${repo}/${ref}/${path}`;
+    const refResponse = await fetch(refUrl, {
+      headers: process.env.GITHUB_TOKEN ? { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` } : {}
+    });
+    if (refResponse.ok) {
+      return refResponse.text();
+    }
+  }
+  const mainUrl = `${RAW_BASE}/${owner}/${repo}/main/${path}`;
+  const mainResponse = await fetch(mainUrl, {
+    headers: process.env.GITHUB_TOKEN ? { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` } : {}
+  });
+  if (mainResponse.ok) {
+    return mainResponse.text();
+  }
+  const masterUrl = `${RAW_BASE}/${owner}/${repo}/master/${path}`;
+  const masterResponse = await fetch(masterUrl, {
+    headers: process.env.GITHUB_TOKEN ? { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` } : {}
+  });
+  if (masterResponse.ok) {
+    return masterResponse.text();
+  }
+  return null;
+}
+async function fetchJsonFile(owner, repo, path, ref) {
+  const raw = await fetchRawFile(owner, repo, path, ref);
+  if (!raw) return null;
+  return JSON.parse(raw);
+}
+async function fetchRepoTree(owner, repo, ref = "main") {
+  const response = await fetch(
+    `${GITHUB_API}/repos/${owner}/${repo}/git/trees/${encodeURIComponent(ref)}?recursive=1`,
+    { headers: getHeaders() }
+  );
+  if (response.status === 404) return [];
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return Array.isArray(data.tree) ? data.tree : [];
+}
+var listTree = fetchRepoTree;
+function parseStringArrayLiteral(raw) {
+  return [...raw.matchAll(/'([^']+)'/g)].map((match) => match[1]).filter(Boolean);
+}
+function parseTargetAdapterScript(content) {
+  const id = content.match(/id:\s*'([^']+)'/)?.[1];
+  const target = content.match(/target:\s*'([^']+)'/)?.[1];
+  const kind = content.match(/kind:\s*'([^']+)'/)?.[1];
+  const rootSegmentsRaw = content.match(/rootSegments:\s*\[([^\]]*)\]/s)?.[1];
+  const installStateRaw = content.match(/installStatePathSegments:\s*\[([^\]]*)\]/s)?.[1];
+  if (!id || !target || !kind || !rootSegmentsRaw || !installStateRaw) {
+    return null;
+  }
+  const pathMappings = [...content.matchAll(
+    /sourceRelativePath === '([^']+)'[\s\S]*?path\.join\(targetRoot,\s*([^)]+)\)[\s\S]*?'(preserve-relative-path|flatten-copy|sync-root-children)'/g
+  )].map((match) => ({
+    source: match[1],
+    destinationSegments: parseStringArrayLiteral(match[2]),
+    strategy: match[3]
+  }));
+  return {
+    id,
+    target,
+    kind,
+    rootSegments: parseStringArrayLiteral(rootSegmentsRaw),
+    installStatePathSegments: parseStringArrayLiteral(installStateRaw),
+    nativeRootRelativePath: content.match(/nativeRootRelativePath:\s*'([^']+)'/)?.[1],
+    rulesMode: content.includes("createFlatRuleOperations") ? "flatten-copy" : "preserve-relative-path",
+    pathMappings: pathMappings.length > 0 ? pathMappings : void 0
+  };
+}
+async function fetchRepoInstallerConfig(owner, repo, defaultBranch = "main") {
+  const [profilesData, modulesData, componentsData, tree, installStateSource] = await Promise.all([
+    fetchJsonFile(
+      owner,
+      repo,
+      "manifests/install-profiles.json",
+      defaultBranch
+    ),
+    fetchJsonFile(
+      owner,
+      repo,
+      "manifests/install-modules.json",
+      defaultBranch
+    ),
+    fetchJsonFile(
+      owner,
+      repo,
+      "manifests/install-components.json",
+      defaultBranch
+    ),
+    fetchRepoTree(owner, repo, defaultBranch),
+    fetchRawFile(owner, repo, "scripts/lib/install-state.js", defaultBranch)
+  ]);
+  if (!profilesData || !modulesData) {
+    return null;
+  }
+  const adapterPaths = tree.filter(
+    (item) => item.type === "blob" && item.path.startsWith("scripts/lib/install-targets/") && item.path.endsWith(".js") && !item.path.endsWith("/helpers.js") && !item.path.endsWith("/registry.js")
+  ).map((item) => item.path);
+  const adapterSources = await Promise.all(
+    adapterPaths.map((path) => fetchRawFile(owner, repo, path, defaultBranch))
+  );
+  const targetAdapters = adapterSources.map((content) => content ? parseTargetAdapterScript(content) : null).filter((adapter) => adapter !== null);
+  const installStateVersion = installStateSource?.match(/schemaVersion:\s*'([^']+)'/)?.[1] ?? "ecc.install.v1";
+  const targets = [...new Set(modulesData.modules.flatMap((module) => module.targets))];
+  return {
+    version: profilesData.version ?? modulesData.version ?? 1,
+    targets,
+    defaultTarget: targets.includes("claude") ? "claude" : targets[0],
+    defaultProfile: profilesData.profiles.developer ? "developer" : Object.keys(profilesData.profiles)[0],
+    profiles: profilesData.profiles,
+    modules: modulesData.modules,
+    components: componentsData?.components ?? [],
+    targetAdapters,
+    installStateVersion
+  };
+}
+async function fetchRepoMetadata(owner, repo) {
+  const response = await fetch(`${GITHUB_API}/repos/${owner}/${repo}`, {
+    headers: getHeaders()
+  });
+  if (response.status === 404) return null;
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return {
+    name: data.name,
+    fullName: data.full_name,
+    description: data.description ?? null,
+    htmlUrl: data.html_url,
+    homepage: data.homepage ?? null,
+    defaultBranch: data.default_branch,
+    stars: data.stargazers_count ?? 0,
+    topics: Array.isArray(data.topics) ? data.topics : []
+  };
+}
+
+// src/repo-installer.ts
+function isRepoInstallerManifest(manifest) {
+  return Boolean(
+    manifest && typeof manifest === "object" && manifest.type === "repo-installer" && "repoInstall" in manifest
+  );
+}
+function getRepoInstallerManifest(manifest) {
+  return isRepoInstallerManifest(manifest) ? manifest : null;
+}
+function ensureRepoInstallerManifest(artifact) {
+  if (!isRepoInstallerManifest(artifact.manifest)) {
+    throw new CaikError(
+      `${artifact.slug} is not a repo-native installer artifact.`,
+      "Use `caik install` for leaf artifacts and stacks."
+    );
+  }
+  return artifact.manifest;
+}
+function dedupe(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function expandComponentModules(components, ids) {
+  const modules = [];
+  for (const id of dedupe(ids)) {
+    const component = components.find((candidate) => candidate.id === id);
+    if (!component) {
+      throw new CaikError(`Unknown repo install component: ${id}`);
+    }
+    modules.push(...component.modules);
+  }
+  return dedupe(modules);
+}
+function resolveRequestedModuleIds(manifest, request) {
+  const profileId = request.profile ?? manifest.repoInstall.defaultProfile;
+  const profileModules = profileId ? manifest.repoInstall.profiles[profileId]?.modules : void 0;
+  if (profileId && !profileModules) {
+    throw new CaikError(`Unknown repo install profile: ${profileId}`);
+  }
+  const requestedModuleIds = dedupe([
+    ...profileModules ?? [],
+    ...request.modules ?? [],
+    ...expandComponentModules(manifest.repoInstall.components, request.includeComponents ?? [])
+  ]);
+  const excludedModuleIds = new Set(
+    expandComponentModules(manifest.repoInstall.components, request.excludeComponents ?? [])
+  );
+  return {
+    profileId,
+    requestedModuleIds: requestedModuleIds.filter((id) => !excludedModuleIds.has(id)),
+    includedComponentIds: dedupe(request.includeComponents ?? []),
+    excludedComponentIds: dedupe(request.excludeComponents ?? [])
+  };
+}
+function resolveSelectedModules(manifest, target, requestedModuleIds) {
+  const byId = new Map(manifest.repoInstall.modules.map((module) => [module.id, module]));
+  const resolved = /* @__PURE__ */ new Set();
+  const visit = (moduleId) => {
+    const module = byId.get(moduleId);
+    if (!module) {
+      throw new CaikError(`Unknown repo install module: ${moduleId}`);
+    }
+    if (resolved.has(moduleId)) return;
+    resolved.add(moduleId);
+    for (const dep of module.dependencies ?? []) {
+      visit(dep);
+    }
+  };
+  for (const moduleId of requestedModuleIds) {
+    visit(moduleId);
+  }
+  const selectedModules = [];
+  const skippedModules = [];
+  for (const moduleId of resolved) {
+    const module = byId.get(moduleId);
+    if (module.targets.includes(target)) {
+      selectedModules.push(module);
+    } else {
+      skippedModules.push(module);
+    }
+  }
+  return { selectedModules, skippedModules };
+}
+function defaultTargetAdapter(target) {
+  switch (target) {
+    case "claude":
+      return {
+        id: "claude-home",
+        target: "claude",
+        kind: "home",
+        rootSegments: [".claude"],
+        installStatePathSegments: ["ecc", "install-state.json"],
+        nativeRootRelativePath: ".claude-plugin",
+        rulesMode: "preserve-relative-path"
+      };
+    case "cursor":
+      return {
+        id: "cursor-project",
+        target: "cursor",
+        kind: "project",
+        rootSegments: [".cursor"],
+        installStatePathSegments: ["ecc-install-state.json"],
+        nativeRootRelativePath: ".cursor",
+        rulesMode: "flatten-copy"
+      };
+    case "codex":
+      return {
+        id: "codex-home",
+        target: "codex",
+        kind: "home",
+        rootSegments: [".codex"],
+        installStatePathSegments: ["ecc-install-state.json"],
+        nativeRootRelativePath: ".codex",
+        rulesMode: "preserve-relative-path"
+      };
+    case "opencode":
+      return {
+        id: "opencode-home",
+        target: "opencode",
+        kind: "home",
+        rootSegments: [".opencode"],
+        installStatePathSegments: ["ecc-install-state.json"],
+        nativeRootRelativePath: ".opencode",
+        rulesMode: "preserve-relative-path"
+      };
+    case "antigravity":
+      return {
+        id: "antigravity-project",
+        target: "antigravity",
+        kind: "project",
+        rootSegments: [".agent"],
+        installStatePathSegments: ["ecc-install-state.json"],
+        rulesMode: "flatten-copy",
+        pathMappings: [
+          { source: "commands", destinationSegments: ["workflows"] },
+          { source: "agents", destinationSegments: ["skills"] }
+        ]
+      };
+    default:
+      return null;
+  }
+}
+function resolveAdapter(manifest, target) {
+  const adapter = (manifest.repoInstall.targetAdapters ?? []).find(
+    (candidate) => candidate.target === target || candidate.id === target
+  ) ?? defaultTargetAdapter(target);
+  if (!adapter) {
+    throw new CaikError(
+      `Unsupported repo install target: ${target}`,
+      `Supported targets: ${manifest.repoInstall.targets.join(", ")}`
+    );
+  }
+  return adapter;
+}
+function resolveTargetRoot(adapter, projectRoot) {
+  const baseRoot = adapter.kind === "home" ? homedir() : projectRoot ?? process.cwd();
+  return join(baseRoot, ...adapter.rootSegments);
+}
+function getRepoInstallStatePath(manifest, target, projectRoot) {
+  const adapter = resolveAdapter(
+    manifest,
+    target || manifest.repoInstall.defaultTarget || manifest.repoInstall.targets[0]
+  );
+  const targetRoot = resolveTargetRoot(adapter, projectRoot);
+  return {
+    adapter,
+    targetRoot,
+    installStatePath: join(targetRoot, ...adapter.installStatePathSegments)
+  };
+}
+function relativeFilePathsForSource(sourceRelativePath, treeFiles) {
+  if (treeFiles.includes(sourceRelativePath)) {
+    return [sourceRelativePath];
+  }
+  const prefix = `${sourceRelativePath}/`;
+  return treeFiles.filter((path) => path.startsWith(prefix));
+}
+function toFlattenedRuleDestination(targetRoot, sourceRelativePath) {
+  const [, namespace, ...rest] = sourceRelativePath.split("/");
+  const flattened = [namespace, ...rest].filter(Boolean).join("-");
+  return join(targetRoot, "rules", flattened);
+}
+function mapDestinationPath(adapter, targetRoot, sourceRoot, sourceRelativePath) {
+  if (adapter.rulesMode === "flatten-copy" && sourceRoot === "rules") {
+    return {
+      destinationPath: toFlattenedRuleDestination(targetRoot, sourceRelativePath),
+      strategy: "flatten-copy"
+    };
+  }
+  const mapping = adapter.pathMappings?.find((candidate) => candidate.source === sourceRoot);
+  if (mapping) {
+    const relativeSuffix = sourceRelativePath === sourceRoot ? "" : sourceRelativePath.slice(sourceRoot.length + 1);
+    const destinationPath = relativeSuffix ? join(targetRoot, ...mapping.destinationSegments, relativeSuffix) : join(targetRoot, ...mapping.destinationSegments);
+    return {
+      destinationPath,
+      strategy: mapping.strategy ?? "preserve-relative-path"
+    };
+  }
+  if (adapter.nativeRootRelativePath && sourceRoot === adapter.nativeRootRelativePath) {
+    const relativeSuffix = sourceRelativePath === sourceRoot ? "" : sourceRelativePath.slice(sourceRoot.length + 1);
+    return {
+      destinationPath: relativeSuffix ? join(targetRoot, relativeSuffix) : targetRoot,
+      strategy: "sync-root-children"
+    };
+  }
+  return {
+    destinationPath: join(targetRoot, sourceRelativePath),
+    strategy: "preserve-relative-path"
+  };
+}
+async function createRepoInstallPlan(artifact, request) {
+  const manifest = ensureRepoInstallerManifest(artifact);
+  const { adapter, targetRoot, installStatePath } = getRepoInstallStatePath(
+    manifest,
+    request.target,
+    request.projectRoot
+  );
+  const tree = await listTree(
+    manifest.source.owner,
+    manifest.source.repo,
+    manifest.source.defaultBranch
+  );
+  const treeFiles = tree.filter((item) => item.type === "blob").map((item) => item.path);
+  const { profileId, requestedModuleIds, includedComponentIds, excludedComponentIds } = resolveRequestedModuleIds(manifest, request);
+  const { selectedModules, skippedModules } = resolveSelectedModules(
+    manifest,
+    adapter.target,
+    requestedModuleIds
+  );
+  const operations = [];
+  for (const module of selectedModules) {
+    for (const sourceRoot of module.paths) {
+      const matchedFiles = relativeFilePathsForSource(sourceRoot, treeFiles);
+      for (const sourceRelativePath of matchedFiles) {
+        const { destinationPath, strategy } = mapDestinationPath(
+          adapter,
+          targetRoot,
+          sourceRoot,
+          sourceRelativePath
+        );
+        operations.push({
+          moduleId: module.id,
+          sourcePath: sourceRelativePath,
+          sourceRelativePath,
+          destinationPath,
+          strategy
+        });
+      }
+    }
+  }
+  return {
+    slug: artifact.slug,
+    name: artifact.name,
+    manifest,
+    adapter,
+    targetRoot,
+    installStatePath,
+    profileId,
+    requestedModuleIds,
+    selectedModules,
+    skippedModules,
+    includedComponentIds,
+    excludedComponentIds,
+    operations
+  };
+}
+function buildInstallState(plan) {
+  return {
+    schemaVersion: plan.manifest.repoInstall.installStateVersion,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    slug: plan.slug,
+    target: plan.adapter.target,
+    targetInfo: {
+      id: plan.adapter.id,
+      target: plan.adapter.target,
+      kind: plan.adapter.kind,
+      root: plan.targetRoot,
+      installStatePath: plan.installStatePath
+    },
+    request: {
+      profile: plan.profileId ?? null,
+      modules: plan.requestedModuleIds,
+      includeComponents: plan.includedComponentIds,
+      excludeComponents: plan.excludedComponentIds
+    },
+    resolution: {
+      selectedModules: plan.selectedModules.map((module) => module.id),
+      skippedModules: plan.skippedModules.map((module) => module.id)
+    },
+    source: {
+      repoUrl: plan.manifest.url,
+      owner: plan.manifest.source.owner,
+      repo: plan.manifest.source.repo,
+      defaultBranch: plan.manifest.source.defaultBranch
+    },
+    operations: plan.operations
+  };
+}
+async function applyRepoInstallPlan(plan) {
+  const writtenFiles = [];
+  try {
+    for (const operation of plan.operations) {
+      const content = await fetchRawFile(
+        plan.manifest.source.owner,
+        plan.manifest.source.repo,
+        operation.sourcePath,
+        plan.manifest.source.defaultBranch
+      );
+      if (content == null) {
+        throw new CaikError(`Missing source file in repo install: ${operation.sourcePath}`);
+      }
+      mkdirSync(dirname(operation.destinationPath), { recursive: true });
+      writeFileSync(operation.destinationPath, content, "utf-8");
+      writtenFiles.push(operation.destinationPath);
+    }
+    mkdirSync(dirname(plan.installStatePath), { recursive: true });
+    writeFileSync(plan.installStatePath, JSON.stringify(buildInstallState(plan), null, 2), "utf-8");
+    writtenFiles.push(plan.installStatePath);
+    return { writtenFiles, installStatePath: plan.installStatePath };
+  } catch (error) {
+    for (const filePath of writtenFiles.reverse()) {
+      try {
+        rmSync(filePath, { force: true });
+      } catch {
+      }
+    }
+    throw error;
+  }
+}
+function readRepoInstallState(statePath) {
+  if (!existsSync(statePath)) {
+    throw new CaikError(`Repo install state not found: ${statePath}`);
+  }
+  return JSON.parse(readFileSync(statePath, "utf-8"));
+}
+async function uninstallRepoInstall(plan) {
+  const state = readRepoInstallState(plan.installStatePath);
+  const removed = [];
+  for (const operation of [...state.operations].reverse()) {
+    if (existsSync(operation.destinationPath)) {
+      rmSync(operation.destinationPath, { force: true });
+      removed.push(operation.destinationPath);
+    }
+  }
+  if (existsSync(plan.installStatePath)) {
+    rmSync(plan.installStatePath, { force: true });
+    removed.push(plan.installStatePath);
+  }
+  return removed;
+}
+async function resolveRepoInstallPlan(options) {
+  return createRepoInstallPlan({
+    id: options.slug,
+    slug: options.slug,
+    name: options.name,
+    description: "",
+    primitive: "reference",
+    tags: [],
+    platforms: [],
+    qualityScore: 0,
+    qualitySignals: null,
+    installCount: 0,
+    ecosystemInstalls: 0,
+    githubStars: 0,
+    sourceCount: 1,
+    trustLevel: "pending",
+    authorHandle: null,
+    authorDisplayName: null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    content: null,
+    manifest: options.manifest,
+    sourceUrl: options.manifest.url,
+    installRef: null,
+    familyId: null,
+    parentId: null,
+    forkRationale: null,
+    params: null,
+    icon: null,
+    author: null
+  }, {
+    target: options.target,
+    profile: options.profileId,
+    modules: options.modules,
+    includeComponents: options.includeComponents,
+    excludeComponents: options.excludeComponents,
+    projectRoot: options.cwd
+  });
+}
+function uninstallRepoInstallState(state) {
+  void uninstallRepoInstall(state);
+}
+
+export {
+  parseSource,
+  listContents,
+  fetchRawFile,
+  fetchRepoInstallerConfig,
+  fetchRepoMetadata,
+  isRepoInstallerManifest,
+  getRepoInstallerManifest,
+  getRepoInstallStatePath,
+  createRepoInstallPlan,
+  applyRepoInstallPlan,
+  readRepoInstallState,
+  uninstallRepoInstall,
+  resolveRepoInstallPlan,
+  uninstallRepoInstallState
+};