deepspace 0.6.2 → 0.8.0

package/dist/feature-installer.js

@@ -0,0 +1,638 @@
+// src/cli/commands/feature-installer.ts
+import {
+  closeSync,
+  copyFileSync,
+  existsSync as existsSync2,
+  fstatSync,
+  mkdirSync,
+  mkdtempSync,
+  openSync,
+  readFileSync as readFileSync2,
+  readSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { spawnSync } from "child_process";
+import { tmpdir } from "os";
+import { dirname, isAbsolute, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/lib/package-manager.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function detectPackageManager(appDir) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(appDir, "package.json"), "utf-8"));
+    const name = typeof pkg.packageManager === "string" ? pkg.packageManager.split("@")[0] : "";
+    if (name === "npm" || name === "pnpm" || name === "yarn" || name === "bun") return name;
+  } catch {
+  }
+  if (existsSync(join(appDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(appDir, "yarn.lock"))) return "yarn";
+  if (existsSync(join(appDir, "bun.lock")) || existsSync(join(appDir, "bun.lockb"))) return "bun";
+  return "npm";
+}
+
+// src/cli/commands/feature-installer.ts
+var NAV_MARKER = "// \u2500\u2500 Features add nav items below this line \u2500\u2500";
+function featurePackageRoot(moduleUrl = import.meta.url) {
+  let dir = dirname(fileURLToPath(moduleUrl));
+  for (; ; ) {
+    const packagePath = join2(dir, "package.json");
+    if (existsSync2(packagePath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(packagePath, "utf-8"));
+        if (pkg.name === "deepspace") return dir;
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) throw new Error("Could not locate the deepspace package root");
+    dir = parent;
+  }
+}
+function hasFeatureCatalog(packageRoot = featurePackageRoot()) {
+  return existsSync2(join2(packageRoot, "features"));
+}
+function readFeatureConfig(id, packageRoot = featurePackageRoot()) {
+  const configPath = join2(packageRoot, "features", id, "feature.json");
+  if (!existsSync2(configPath)) return null;
+  try {
+    const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+    if (typeof config.id !== "string" || typeof config.name !== "string" || !Array.isArray(config.files)) {
+      return null;
+    }
+    return config;
+  } catch {
+    return null;
+  }
+}
+function listFeatureConfigs(packageRoot = featurePackageRoot()) {
+  const featuresDir = join2(packageRoot, "features");
+  if (!existsSync2(featuresDir)) return [];
+  return readdirSync(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => readFeatureConfig(entry.name, packageRoot)).filter((config) => config !== null && !config.internal).sort((a, b) => a.id.localeCompare(b.id));
+}
+function featureCatalog(packageRoot = featurePackageRoot()) {
+  return listFeatureConfigs(packageRoot).map((config) => ({
+    id: config.id,
+    name: config.name,
+    category: config.category ?? null,
+    description: config.description ?? null
+  }));
+}
+function editDistance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i++) {
+    let previous = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const current = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+      previous = current;
+    }
+  }
+  return row[b.length];
+}
+function suggestFeature(featureId, packageRoot = featurePackageRoot()) {
+  let closest = null;
+  let closestDistance = Number.POSITIVE_INFINITY;
+  for (const feature of listFeatureConfigs(packageRoot)) {
+    const distance = editDistance(featureId, feature.id);
+    if (distance < closestDistance) {
+      closest = feature.id;
+      closestDistance = distance;
+    }
+  }
+  const threshold = Math.max(2, Math.floor(featureId.length / 3));
+  return closest !== null && closestDistance <= threshold ? closest : null;
+}
+function resolveTargetDir(raw) {
+  return isAbsolute(raw) ? raw : resolve(raw);
+}
+function resolveFeatureDestPath(fileDest, route) {
+  const pages = "src/pages/";
+  const appPages = "src/pages/(app)/";
+  if (!fileDest.startsWith(pages) || fileDest.startsWith(appPages)) return fileDest;
+  const rest = fileDest.slice(pages.length);
+  return route?.protected === false ? `${appPages}${rest}` : `${appPages}(protected)/${rest}`;
+}
+function copyFile(src, dest) {
+  mkdirSync(dirname(dest), { recursive: true });
+  copyFileSync(src, dest);
+}
+function copyFileWithImportShift(src, dest, levels) {
+  mkdirSync(dirname(dest), { recursive: true });
+  const prefix = "../".repeat(levels);
+  const shifted = readFileSync2(src, "utf-8").replace(
+    /(from\s+|import\s+|import\()(['"])(\.\.\/)/g,
+    `$1$2${prefix}$3`
+  );
+  writeFileSync(dest, shifted);
+}
+function installFiles(packageRoot, config, targetDir, emit) {
+  let copied = 0;
+  let skipped = 0;
+  const created = [];
+  const preexisting = [];
+  const missing = [];
+  for (const file of config.files) {
+    const srcPath = join2(packageRoot, "features", config.id, file.src);
+    const resolvedDest = resolveFeatureDestPath(file.dest, config.route);
+    const destPath = join2(targetDir, resolvedDest);
+    const existed = existsSync2(destPath);
+    if (existed) preexisting.push(resolvedDest);
+    if (!existsSync2(srcPath)) {
+      emit(`   Warning: source not found: ${file.src}`, "stderr");
+      if (!existed) missing.push(resolvedDest);
+      continue;
+    }
+    if (existed && !file.overwrite) {
+      emit(`   Exists (skipped): ${resolvedDest}`);
+      skipped++;
+      continue;
+    }
+    const wasRedirected = resolvedDest !== file.dest;
+    const shiftLevels = resolvedDest.split("/").length - file.dest.split("/").length;
+    if (wasRedirected) copyFileWithImportShift(srcPath, destPath, shiftLevels);
+    else copyFile(srcPath, destPath);
+    emit(`   ${existed ? "Overwrote" : "Copied"}: ${resolvedDest}`);
+    if (!existed) created.push(resolvedDest);
+    copied++;
+  }
+  return { copied, skipped, files: { created, preexisting, missing } };
+}
+function unresolvedSchema(schema, reason, emit) {
+  const entry = schema.spreadOperator ? `...${schema.exportName}` : schema.exportName;
+  emit("");
+  emit("   Add manually to src/schemas.ts:");
+  emit(`     import { ${schema.exportName} } from '${schema.importPath}'`);
+  emit(`     // then add ${entry} to the schemas array`);
+  return {
+    area: "schema",
+    reason,
+    steps: [
+      `Add import { ${schema.exportName} } from '${schema.importPath}' to src/schemas.ts.`,
+      `Add ${entry} to the exported schemas array.`
+    ]
+  };
+}
+function integrateSchema(config, targetDir, emit) {
+  if (!config.schema) return [];
+  const schemasPath = join2(targetDir, "src", "schemas.ts");
+  if (!existsSync2(schemasPath)) {
+    return [unresolvedSchema(config.schema, "src/schemas.ts was not found.", emit)];
+  }
+  let content = readFileSync2(schemasPath, "utf-8");
+  const { exportName, importPath, spreadOperator } = config.schema;
+  const importPattern = new RegExp(`^import\\s+\\{[^}]*\\b${exportName}\\b`, "m");
+  if (importPattern.test(content)) {
+    emit(`   Schema already present: ${exportName}`);
+    return [];
+  }
+  if (!content.includes("export const schemas") || !/export const schemas:\s*CollectionSchema\[\]\s*=\s*\[/.test(content)) {
+    const reason = "src/schemas.ts has an unexpected structure.";
+    emit(`   Could not auto-integrate schema (${reason})`);
+    return [unresolvedSchema(config.schema, reason, emit)];
+  }
+  const importLine = `import { ${exportName} } from '${importPath}'`;
+  const withImport = content.replace(
+    /export const schemas/,
+    `${importLine}
+
+export const schemas`
+  );
+  const schemaEntry = spreadOperator ? `...${exportName}` : exportName;
+  const withEntry = withImport.replace(
+    /export const schemas:\s*CollectionSchema\[\]\s*=\s*\[/,
+    `export const schemas: CollectionSchema[] = [
+  ${schemaEntry},`
+  );
+  if (withImport === content || withEntry === withImport) {
+    const reason = "src/schemas.ts could not be updated safely.";
+    emit(`   Could not auto-integrate schema (${reason})`);
+    return [unresolvedSchema(config.schema, reason, emit)];
+  }
+  content = withEntry;
+  writeFileSync(schemasPath, content);
+  emit(`   Schema integrated: ${exportName} -> schemas.ts`);
+  return [];
+}
+function unresolvedActions(actions, reason, emit) {
+  emit("");
+  emit("   Add manually to src/actions/index.ts:");
+  for (const action of actions) {
+    emit(`     import { ${action.exportName} } from '${action.importPath}'`);
+    emit(`     // then add '${action.registerAs}': ${action.exportName} to the actions object`);
+  }
+  return {
+    area: "actions",
+    reason,
+    steps: actions.flatMap((action) => [
+      `Add import { ${action.exportName} } from '${action.importPath}' to src/actions/index.ts.`,
+      `Register '${action.registerAs}': ${action.exportName} in the exported actions object.`
+    ])
+  };
+}
+function integrateActions(config, targetDir, emit) {
+  if (!config.actions?.length) return [];
+  const actionsPath = join2(targetDir, "src", "actions", "index.ts");
+  if (!existsSync2(actionsPath)) {
+    return [unresolvedActions(config.actions, "src/actions/index.ts was not found.", emit)];
+  }
+  let content = readFileSync2(actionsPath, "utf-8");
+  const registryPattern = /export const actions:\s*Record<string,\s*ActionHandler(?:<[^>]*>)?>\s*=\s*\{/;
+  if (!registryPattern.test(content)) {
+    const reason = "src/actions/index.ts has an unexpected structure.";
+    emit(`   Could not auto-integrate actions (${reason})`);
+    return [unresolvedActions(config.actions, reason, emit)];
+  }
+  let integrated = 0;
+  const unresolved = [];
+  for (const action of config.actions) {
+    const importPattern = new RegExp(`^import\\s+\\{[^}]*\\b${action.exportName}\\b`, "m");
+    if (importPattern.test(content)) {
+      emit(`   Action already present: ${action.registerAs}`);
+      continue;
+    }
+    const importLine = `import { ${action.exportName} } from '${action.importPath}'`;
+    const withImport = content.replace(
+      /export const actions:/,
+      `${importLine}
+
+export const actions:`
+    );
+    const registryEntry = `  '${action.registerAs}': ${action.exportName},`;
+    const withEntry = withImport.replace(registryPattern, (match) => `${match}
+${registryEntry}`);
+    if (withImport === content || withEntry === withImport) {
+      emit(`   Could not integrate action: ${action.registerAs}`);
+      unresolved.push(
+        unresolvedActions(
+          [action],
+          `Action '${action.registerAs}' could not be registered safely.`,
+          emit
+        )
+      );
+      continue;
+    }
+    content = withEntry;
+    integrated++;
+    emit(`   Action integrated: ${action.registerAs} (${action.exportName})`);
+  }
+  if (integrated > 0) writeFileSync(actionsPath, content);
+  return unresolved;
+}
+function integrateCss(packageRoot, config, targetDir, emit) {
+  if (!config.css?.length) return [];
+  const stylesPath = join2(targetDir, "src", "styles.css");
+  if (!existsSync2(stylesPath)) {
+    emit("   Warning: Cannot integrate CSS \u2014 src/styles.css not found");
+    return [
+      {
+        area: "css",
+        reason: "src/styles.css was not found.",
+        steps: config.css.map(
+          (cssFile) => `Append node_modules/deepspace/features/${config.id}/${cssFile} to src/styles.css.`
+        )
+      }
+    ];
+  }
+  let styles = readFileSync2(stylesPath, "utf-8");
+  let integrated = 0;
+  const unresolved = [];
+  for (const cssFile of config.css) {
+    const srcPath = join2(packageRoot, "features", config.id, cssFile);
+    if (!existsSync2(srcPath)) {
+      emit(`   Warning: CSS source not found: ${cssFile}`, "stderr");
+      unresolved.push({
+        area: "css",
+        reason: `Feature CSS source '${cssFile}' was not found in the installed package.`,
+        steps: ["Reinstall the current deepspace package, then retry this feature installation."]
+      });
+      continue;
+    }
+    const css = readFileSync2(srcPath, "utf-8");
+    const fingerprint = css.match(/\.([\w-]+)\s*\{|@keyframes\s+([\w-]+)/);
+    const marker = fingerprint?.[1] ?? fingerprint?.[2];
+    if (marker && styles.includes(marker)) {
+      emit(`   CSS already present: ${cssFile} (found .${marker})`);
+      continue;
+    }
+    styles += `
+${css}`;
+    integrated++;
+    emit(`   CSS integrated: ${cssFile} -> styles.css`);
+  }
+  if (integrated > 0) writeFileSync(stylesPath, styles);
+  return unresolved;
+}
+function unresolvedRoute(route, config, reason, emit) {
+  emit("");
+  emit("   Add manually to src/nav.ts:");
+  emit(`     { path: '${route.path}', label: '${config.name}' },`);
+  return {
+    area: "nav",
+    reason,
+    steps: [`Add { path: '${route.path}', label: '${config.name}' } to the exported nav array.`]
+  };
+}
+function integrateRoute(config, targetDir, emit) {
+  if (!config.route) return [];
+  const navPath = join2(targetDir, "src", "nav.ts");
+  if (!existsSync2(navPath)) {
+    return [unresolvedRoute(config.route, config, "src/nav.ts was not found.", emit)];
+  }
+  let content = readFileSync2(navPath, "utf-8");
+  const routePath = config.route.path;
+  if (content.includes(`'${routePath}'`)) {
+    emit(`   Nav already present: ${routePath}`);
+    return [];
+  }
+  if (!content.includes(NAV_MARKER)) {
+    emit("   Could not auto-wire nav (marker not found in nav.ts)");
+    return [
+      unresolvedRoute(
+        config.route,
+        config,
+        "The feature insertion marker was not found in src/nav.ts.",
+        emit
+      )
+    ];
+  }
+  const roles = config.route.protected === false ? "" : ", roles: ['member' as Role]";
+  const entry = `  { path: '${routePath}', label: '${config.name}'${roles} },`;
+  content = content.replace(NAV_MARKER, `${NAV_MARKER}
+${entry}`);
+  writeFileSync(navPath, content);
+  emit(`   Nav wired: ${routePath} (${config.name})`);
+  emit("   Route: automatic (file-based routing via src/pages/)");
+  return [];
+}
+var INSTALL_DIAGNOSTIC_BYTES = 16 * 1024;
+function readDiagnosticTail(outputFd) {
+  const size = fstatSync(outputFd).size;
+  if (size === 0) return void 0;
+  const length = Math.min(size, INSTALL_DIAGNOSTIC_BYTES);
+  const buffer = Buffer.alloc(length);
+  readSync(outputFd, buffer, 0, length, size - length);
+  const tail = buffer.toString("utf-8").trim();
+  if (!tail) return void 0;
+  return size > length ? `[last ${length} bytes]
+${tail}` : tail;
+}
+function runPackageInstall(packageManager, targetDir, outputVisible) {
+  const options = {
+    cwd: targetDir,
+    shell: process.platform === "win32"
+  };
+  if (outputVisible) {
+    const child = spawnSync(packageManager, ["install"], { ...options, stdio: "inherit" });
+    return { error: child.error, status: child.status };
+  }
+  const captureDir = mkdtempSync(join2(tmpdir(), "deepspace-add-install-"));
+  let outputFd;
+  try {
+    outputFd = openSync(join2(captureDir, "output.log"), "w+");
+    const child = spawnSync(packageManager, ["install"], {
+      ...options,
+      stdio: ["ignore", outputFd, outputFd]
+    });
+    return {
+      error: child.error,
+      status: child.status,
+      diagnosticTail: readDiagnosticTail(outputFd)
+    };
+  } finally {
+    if (outputFd !== void 0) closeSync(outputFd);
+    rmSync(captureDir, { recursive: true, force: true });
+  }
+}
+function integrateDependencies(config, targetDir, runInstall, outputVisible, emit) {
+  const packageManager = detectPackageManager(targetDir);
+  const declarations = [
+    { section: "dependencies", values: config.dependencies },
+    { section: "devDependencies", values: config.devDependencies }
+  ];
+  if (declarations.every(({ values }) => !values || Object.keys(values).length === 0)) {
+    return { added: [], installRan: false, packageManager };
+  }
+  const packagePath = join2(targetDir, "package.json");
+  if (!existsSync2(packagePath)) {
+    emit("   Could not patch package.json (file not found)");
+    return { added: [], installRan: false, packageManager };
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync2(packagePath, "utf-8"));
+  } catch (error) {
+    emit(
+      `   Could not patch package.json (parse error: ${error instanceof Error ? error.message : String(error)})`
+    );
+    return { added: [], installRan: false, packageManager };
+  }
+  const added = [];
+  const skipped = [];
+  for (const { section, values } of declarations) {
+    if (!values) continue;
+    pkg[section] ??= {};
+    for (const [name, version] of Object.entries(values)) {
+      if (pkg.dependencies?.[name] || pkg.devDependencies?.[name]) {
+        if (!added.some((dependency) => dependency.name === name)) skipped.push(name);
+        continue;
+      }
+      pkg[section][name] = version;
+      added.push({ name, section, version });
+    }
+  }
+  if (added.length === 0) {
+    emit("   Dependencies already present");
+  } else {
+    writeFileSync(packagePath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+    emit(`   Added to package.json: ${added.map(({ name }) => name).join(", ")}`);
+    if (skipped.length) emit(`   Already present (kept your version): ${skipped.join(", ")}`);
+  }
+  if (!runInstall) return { added, installRan: false, packageManager };
+  emit("");
+  emit(`   Installing dependencies with ${packageManager}...`);
+  const child = runPackageInstall(packageManager, targetDir, outputVisible);
+  if (child.error) {
+    const error = child.error;
+    const reason = error.code === "ENOENT" ? `${packageManager} not found on PATH` : error.message;
+    return {
+      added,
+      installRan: false,
+      installError: `Could not launch ${packageManager} (${reason}).`,
+      diagnosticTail: child.diagnosticTail,
+      packageManager
+    };
+  }
+  if (child.status !== 0) {
+    const diagnostic = child.diagnosticTail ? `
+Diagnostic tail:
+${child.diagnosticTail}` : "";
+    return {
+      added,
+      installRan: false,
+      installError: `${packageManager} install did not complete (exit ${child.status ?? "unknown"}).${diagnostic}`,
+      diagnosticTail: child.diagnosticTail,
+      packageManager
+    };
+  }
+  return { added, installRan: true, packageManager };
+}
+function dependencySnapshot(targetDir) {
+  try {
+    const pkg = JSON.parse(readFileSync2(join2(targetDir, "package.json"), "utf-8"));
+    return {
+      dependencies: pkg.dependencies ?? {},
+      devDependencies: pkg.devDependencies ?? {}
+    };
+  } catch {
+    return { dependencies: {}, devDependencies: {} };
+  }
+}
+function installedNavFeatures(packageRoot, targetDir) {
+  return listFeatureConfigs(packageRoot).filter((feature) => feature.category === "nav" && feature.files.length > 0).filter((feature) => {
+    const signature = resolveFeatureDestPath(feature.files[0].dest, feature.route);
+    return existsSync2(join2(targetDir, signature));
+  }).map((feature) => feature.id);
+}
+function warnNavConflicts(packageRoot, config, targetDir, emit) {
+  if (config.category !== "nav") return;
+  const present = installedNavFeatures(packageRoot, targetDir);
+  if (present.length <= 1) return;
+  emit("");
+  emit(`\u26A0 Multiple navigation features present (${present.join(", ")}).`);
+  emit("  sidebar, topbar, and tree are mutually exclusive \u2014 keep one and remove the");
+  emit("  others to avoid competing navigation in your layout.");
+}
+function installFeature(options) {
+  const packageRoot = featurePackageRoot();
+  const targetDir = resolveTargetDir(options.targetDir);
+  const config = readFeatureConfig(options.feature, packageRoot);
+  if (!config) {
+    const suggestion = suggestFeature(options.feature, packageRoot);
+    return {
+      ok: false,
+      code: "unknown_feature",
+      error: [
+        `Unknown feature: ${options.feature}`,
+        ...suggestion ? [`Did you mean "${suggestion}"?`] : []
+      ].join("\n"),
+      data: {
+        requestedFeature: options.feature,
+        suggestedFeature: suggestion,
+        availableFeatures: featureCatalog(packageRoot)
+      }
+    };
+  }
+  const emit = options.emit ?? (() => void 0);
+  emit("");
+  emit(`Installing: ${config.name}`);
+  emit(`   ${config.description ?? ""}`);
+  emit(`   Target: ${targetDir}`);
+  const installedFiles = installFiles(packageRoot, config, targetDir, emit);
+  emit("");
+  emit(
+    `Copied ${installedFiles.copied} file(s)${installedFiles.skipped > 0 ? `, skipped ${installedFiles.skipped} existing` : ""}`
+  );
+  const unresolvedIntegrations = [
+    ...integrateSchema(config, targetDir, emit),
+    ...integrateActions(config, targetDir, emit),
+    ...integrateCss(packageRoot, config, targetDir, emit),
+    ...integrateRoute(config, targetDir, emit)
+  ];
+  const dependencyResult = integrateDependencies(
+    config,
+    targetDir,
+    options.installDependencies,
+    options.emit !== void 0,
+    emit
+  );
+  if (config.instructions?.length) {
+    emit("");
+    emit("--- Manual wiring needed ---");
+    emit("");
+    config.instructions.forEach((instruction, index) => {
+      emit(`${index + 1}. ${instruction}`);
+      emit("");
+    });
+  }
+  if (config.patterns?.length) {
+    emit("--- Key patterns ---");
+    emit("");
+    config.patterns.forEach((pattern) => emit(`- ${pattern}`));
+    emit("");
+  }
+  warnNavConflicts(packageRoot, config, targetDir, emit);
+  const dependenciesAfter = dependencySnapshot(targetDir);
+  const declaredDependencies = [
+    ...Object.keys(config.dependencies ?? {}),
+    ...Object.keys(config.devDependencies ?? {})
+  ];
+  const missingDeclarations = declaredDependencies.filter(
+    (name) => !(name in dependenciesAfter.dependencies) && !(name in dependenciesAfter.devDependencies)
+  );
+  const installed = installedFiles.files.missing.length === 0 && missingDeclarations.length === 0 && unresolvedIntegrations.length === 0 && dependencyResult.installError === void 0;
+  const dependencyInstallRequired = installed && dependencyResult.added.length > 0 && !options.installDependencies && !dependencyResult.installRan;
+  const data = {
+    feature: config.id,
+    dir: targetDir,
+    installed,
+    observedChanges: {
+      files: installedFiles.files,
+      dependencies: {
+        added: dependencyResult.added,
+        missingDeclarations,
+        installRequested: options.installDependencies,
+        ...dependencyResult.diagnosticTail ? { diagnosticTail: dependencyResult.diagnosticTail } : {}
+      }
+    },
+    unresolvedIntegrations,
+    manifestGuidance: {
+      instructions: config.instructions ?? [],
+      patterns: config.patterns ?? [],
+      agentNotes: config.agentNotes ?? []
+    }
+  };
+  if (dependencyResult.installError) {
+    return {
+      ok: false,
+      code: "dependency_install_failed",
+      error: dependencyResult.installError,
+      data
+    };
+  }
+  if (unresolvedIntegrations.length > 0) {
+    const count = unresolvedIntegrations.length;
+    return {
+      ok: false,
+      code: "manual_integration_required",
+      error: `${count} app integration${count === 1 ? "" : "s"} require manual completion. Follow the unresolved integration steps, then run your checks.`,
+      data
+    };
+  }
+  return {
+    ok: true,
+    data,
+    ...dependencyInstallRequired ? {
+      action: {
+        cwd: targetDir,
+        argv: [dependencyResult.packageManager, "install"]
+      }
+    } : {}
+  };
+}
+export {
+  featureCatalog,
+  featurePackageRoot,
+  hasFeatureCatalog,
+  installFeature,
+  listFeatureConfigs,
+  readFeatureConfig,
+  resolveFeatureDestPath,
+  suggestFeature
+};
+//# sourceMappingURL=feature-installer.js.map