Function runInit

src/bin/codegraph.ts:617–701

* The `init` flow — shared by `codegraph init` and `codegraph install --init` * (#1578): refuse an unsafe root, create `.codegraph/`, build the initial * index under supervision, then the post-index offers. `yes` makes every * offer non-interactive (defaults only), so a container / CI bootstrap n

(
  projectPath: string,
  options: { index?: boolean; force?: boolean; verbose?: boolean; yes?: boolean },
)

 * (no `--force` is implied by any caller); an index failure exits 1.
 */
async function runInit(
  projectPath: string,
  options: { index?: boolean; force?: boolean; verbose?: boolean; yes?: boolean },
): Promise<void> {
  const clack = await importESM('@clack/prompts');

  clack.intro('Initializing CodeGraph');

  try {
    // Refuse to index your home directory / a filesystem root — it pulls in
    // caches, other projects, and your whole tree (a multi-GB index + watcher
    // churn, and on pre-1.0 macOS a machine-crashing fd blowup, #845).
    const unsafe = unsafeIndexRootReason(projectPath);
    if (unsafe && !options.force) {
      clack.log.error(`Refusing to initialize in ${projectPath} — it looks like ${unsafe}.`);
      clack.log.info('Run this inside a specific project directory, or pass --force if you really mean to index everything under it.');
      clack.outro('');
      process.exitCode = 1;
      return;
    }

    if (isInitialized(projectPath)) {
      clack.log.warn(`Already initialized in ${projectPath}`);
      clack.log.info('Use "codegraph index" to re-index or "codegraph sync" to update');
      try {
        const { offerWatchFallback } = await import('../installer');
        await offerWatchFallback(clack, projectPath, { yes: options.yes });
      } catch { /* non-fatal */ }
      clack.outro('');
      return;
    }

    const { default: CodeGraph, getDatabasePath } = await loadCodeGraph();
    const cg = await CodeGraph.init(projectPath, { index: false });
    clack.log.success(`Initialized in ${projectPath}`);

    // Indexing runs by default now. The legacy -i/--index flag is still
    // accepted (so existing muscle memory and scripts don't break) but is a
    // no-op — initializing always builds the initial index.
    // Supervise the index: self-terminate if orphaned or wedged (#999).
    // The DB + WAL paths let the liveness watchdog tell a slow store on
    // degraded storage from a true wedge (#1231).
    // A closure so we can re-run the exact same supervised, progress-rendered
    // index if the user opts gitignored child repos in below (#1156).
    const dbPath = getDatabasePath(projectPath);
    const runIndex = async (): Promise<IndexResult> => {
      const supervision = installCommandSupervision('init', { progressPaths: [dbPath, `${dbPath}-wal`] });
      try {
        if (options.verbose) {
          return await cg.indexAll({ onProgress: createVerboseProgress(), verbose: true });
        }
        process.stdout.write(`${colors.dim}${getGlyphs().rail}${colors.reset}\n`);
        const progress = createShimmerProgress();
        const r = await cg.indexAll({ onProgress: progress.onProgress });
        await progress.stop();
        return r;
      } finally {
        supervision.stop();