@bastani/atomic 0.5.0 → 0.5.1

package/src/services/system/workflows.ts

@@ -14,7 +14,7 @@
  */
 
 import { join, sep } from "path";
-import { readdir, rm } from "fs/promises";
+import { lstat, readdir, rm, symlink, unlink } from "fs/promises";
 import { homedir } from "os";
 import {
   copyDir,
@@ -46,6 +46,41 @@ function packageRoot(): string {
   return join(import.meta.dir, "..", "..", "..");
 }
 
+/**
+ * Safely remove a symlink or junction before re-creating it.
+ *
+ * On Windows, Bun's `rm({ recursive: true })` follows NTFS junctions and
+ * can delete the **target directory's contents** (oven-sh/bun#27233).
+ * `unlink` is safe: it opens with `FILE_FLAG_OPEN_REPARSE_POINT` and
+ * removes only the link entry, never following it.
+ *
+ * Falls back to `rm` only when the path is a real directory (not a link),
+ * which can happen if a previous version created the path as a plain copy
+ * instead of a symlink.
+ */
+async function removeLinkOrDir(path: string): Promise<void> {
+  try {
+    const stats = await lstat(path);
+    if (stats.isSymbolicLink()) {
+      await unlink(path);
+    } else if (stats.isDirectory()) {
+      await rm(path, { recursive: true, force: true });
+    } else {
+      await unlink(path);
+    }
+  } catch (error: unknown) {
+    // ENOENT — path doesn't exist; nothing to remove.
+    if (
+      error instanceof Error &&
+      "code" in error &&
+      (error as NodeJS.ErrnoException).code === "ENOENT"
+    ) {
+      return;
+    }
+    throw error;
+  }
+}
+
 /** Honors ATOMIC_SETTINGS_HOME so tests can point at a temp dir. */
 function homeRoot(): string {
   return process.env.ATOMIC_SETTINGS_HOME ?? homedir();
@@ -102,4 +137,104 @@ export async function installGlobalWorkflows(): Promise<void> {
       await copyDir(src, dest);
     }
   }
+
+  // ── Type-resolution setup for workflow authors ─────────────────────
+  //
+  // The bundled tsconfig.json uses relative `paths` that only resolve
+  // correctly inside the package's own directory tree. Once the files
+  // are copied to `~/.atomic/workflows/`, those relative paths break.
+  //
+  // Strategy: symlink `node_modules/@bastani/atomic` in the destination
+  // back to the running package root.  TypeScript's standard module
+  // resolution then finds `@bastani/atomic/workflows` (and its
+  // transitive deps) automatically — no `paths` override needed.
+  //
+  // If symlink creation fails (permissions, unsupported FS), we fall
+  // back to a tsconfig with an absolute `paths` entry pointing at the
+  // package's SDK source.  Either way the workflow author gets types
+  // with zero manual configuration.
+  await setupWorkflowTypes(destRoot);
+}
+
+/**
+ * Wire up TypeScript type resolution for a global workflows directory.
+ *
+ * Creates a `node_modules/@bastani/atomic` symlink → the installed
+ * package root and generates a tsconfig.json that lets standard module
+ * resolution do the work. Falls back to absolute `paths` in the
+ * tsconfig if symlinking isn't possible.
+ */
+export async function setupWorkflowTypes(destRoot: string): Promise<void> {
+  const pkgRoot = packageRoot();
+  let usedSymlink = false;
+
+  // 1. Symlink the package itself
+  try {
+    const scopeDir = join(destRoot, "node_modules", "@bastani");
+    await ensureDir(scopeDir);
+
+    const link = join(scopeDir, "atomic");
+    await removeLinkOrDir(link);
+
+    // Junctions on Windows need no elevated privileges.
+    const type = process.platform === "win32" ? "junction" : "dir";
+    await symlink(pkgRoot, link, type);
+    usedSymlink = true;
+  } catch {
+    // Swallow — falls back to paths-based tsconfig below.
+  }
+
+  // 2. Symlink @types/bun so `Bun.*` APIs have types in workflows
+  try {
+    const bunTypes = join(pkgRoot, "node_modules", "@types", "bun");
+    if (await pathExists(bunTypes)) {
+      const typesDir = join(destRoot, "node_modules", "@types");
+      await ensureDir(typesDir);
+
+      const link = join(typesDir, "bun");
+      await removeLinkOrDir(link);
+
+      const type = process.platform === "win32" ? "junction" : "dir";
+      await symlink(bunTypes, link, type);
+    }
+  } catch {
+    // Best effort — Bun APIs in workflows lack types but runtime is fine.
+  }
+
+  // 3. Generate a clean tsconfig for the destination
+  const compilerOptions: Record<string, unknown> = {
+    target: "ESNext",
+    module: "ESNext",
+    moduleResolution: "bundler",
+    allowImportingTsExtensions: true,
+    noEmit: true,
+    verbatimModuleSyntax: true,
+    strict: true,
+    skipLibCheck: true,
+    types: ["bun"],
+  };
+
+  if (!usedSymlink) {
+    // Fallback: absolute paths so TypeScript can still resolve the SDK
+    // source from the installed package location.
+    compilerOptions.paths = {
+      "@bastani/atomic": [join(pkgRoot, "src", "sdk", "index.ts")],
+      "@bastani/atomic/workflows": [join(pkgRoot, "src", "sdk", "workflows.ts")],
+    };
+  }
+
+  const tsconfig = { compilerOptions, include: GLOBAL_TSCONFIG_INCLUDE };
+
+  await Bun.write(
+    join(destRoot, "tsconfig.json"),
+    JSON.stringify(tsconfig, null, 2) + "\n",
+  );
 }
+
+/** Include globs shared by every generated global workflows tsconfig. */
+const GLOBAL_TSCONFIG_INCLUDE = [
+  "**/claude/**/*.ts",
+  "**/copilot/**/*.ts",
+  "**/opencode/**/*.ts",
+  "**/helpers/**/*.ts",
+];