Bun equivalent for node:path?

[deadcoder0904]

I asked different LLMs (even ChatGPT using search) but I couldn't get an answer to this.

ChatGPT wrote its own little helpers:

#!/usr/bin/env bun
import { Glob } from "bun";
import { srt } from "@deepgram/captions";

// Use Bun's import.meta to get the directory of the script
const __dirname = import.meta.dir;

// ANSI escape codes for colors
const COLOR = {
  cyan: "\x1b[36m",
  green: "\x1b[32m",
  red: "\x1b[31m",
  yellow: "\x1b[33m",
  reset: "\x1b[0m",
};

// Helper functions for path operations
const path = {
  dirname: (p) => p.slice(0, p.lastIndexOf("/")),
  basename: (p, ext = "") =>
    ext && p.endsWith(ext) ? p.slice(p.lastIndexOf("/") + 1, -ext.length) : p.slice(p.lastIndexOf("/") + 1),
  join: (...parts) => parts.join("/"),
  resolve: (p) => (p.startsWith("/") ? p : `${__dirname}/${p}`),
};

// Type guard for Deepgram JSON structure
const isDeepgramTranscript = (json) =>
  json &&
  typeof json === "object" &&
  json.metadata?.created &&
  Array.isArray(json.results?.channels) &&
  json.results.channels.every((channel) =>
    Array.isArray(channel.alternatives) &&
    channel.alternatives.every(
      (alt) =>
        Array.isArray(alt.words) &&
        alt.words.every((word) => typeof word.word === "string" && typeof word.start === "number" && typeof word.end === "number")
    )
  );

async function processFiles() {
  try {
    const files = [...(await new Glob("**/*.json").scan("."))];
    
    if (files.length === 0) {
      console.log(`${COLOR.yellow}No JSON files found in the current directory.${COLOR.reset}`);
      return;
    }

    const dirMap = new Map();
    for (const file of files) {
      const dir = path.dirname(file);
      if (!dirMap.has(dir)) dirMap.set(dir, []);
      dirMap.get(dir).push(file);
    }

    let conversionHappened = false;

    for (const [dir, jsonFiles] of dirMap) {
      console.log(`${COLOR.cyan}📁 ${dir}${COLOR.reset}`);

      for (const file of jsonFiles) {
        try {
          const jsonContent = await Bun.file(path.resolve(file)).json();
          if (!isDeepgramTranscript(jsonContent)) continue;

          const srtPath = path.join(dir, `${path.basename(file, ".json")}.srt`);
          await Bun.write(srtPath, srt(jsonContent));
          
          console.log(`  ${COLOR.green}→${COLOR.reset} ${path.basename(file)} → ${path.basename(srtPath)}`);
          conversionHappened = true;
        } catch (error) {
          console.error(`  ${COLOR.red}✗${COLOR.reset} Error processing ${file}: ${error.message}`);
        }
      }
    }

    console.log(
      conversionHappened
        ? `${COLOR.green}✅ All conversions completed successfully.${COLOR.reset}`
        : `${COLOR.yellow}No valid Deepgram JSON files found for conversion.${COLOR.reset}`
    );
  } catch (error) {
    console.error(`${COLOR.red}🚨 Critical error: ${error.message}${COLOR.reset}`);
    process.exit(1);
  }
}

await processFiles();

But I'm curious does Bun not have simple functions like basename, pathname, join, resolve? Is the recommended pattern using node:path only? I thought bun was full replacement for node.

[kravetsone]

man just use node:path lol

[deadcoder0904]

still curious lol.

[deadcoder0904]

It also doesn't have an equivalent for directory either - https://bun.sh/docs/api/file-io#directories

#!/usr/bin/env bun
import { Glob } from "bun";
import { srt } from "@deepgram/captions";
import path from "node:path";
import { existsSync, statSync } from "node:fs";

// ANSI escape codes for colors
const COLOR = {
  cyan: "\x1b[36m",
  green: "\x1b[32m",
  red: "\x1b[31m",
  yellow: "\x1b[33m",
  reset: "\x1b[0m",
};

// Type guard for Deepgram JSON structure
function isDeepgramTranscript(json: any): json is DeepgramSchema {
  return (
    typeof json === "object" &&
    typeof json?.metadata?.created === "string" &&
    Array.isArray(json?.results?.channels) &&
    json.results.channels.every(
      (channel: any) =>
        Array.isArray(channel.alternatives) &&
        channel.alternatives.every(
          (alt: any) =>
            Array.isArray(alt.words) &&
            alt.words.every(
              (word: any) =>
                typeof word.word === "string" &&
                typeof word.start === "number" &&
                typeof word.end === "number",
            ),
        ),
    )
  );
}

async function processFiles() {
  try {
    const targetDirArg = process.argv[2];
    if (!targetDirArg) {
      console.error(
        `${COLOR.red}Error: Please specify a directory to process.${COLOR.reset}`,
      );
      process.exit(1);
    }

    const resolvedDir = path.resolve(targetDirArg);

    if (!existsSync(resolvedDir)) {
      console.error(
        `${COLOR.red}Error: Directory '${resolvedDir}' does not exist.${COLOR.reset}`,
      );
      process.exit(1);
    }

    if (!statSync(resolvedDir).isDirectory()) {
      console.error(
        `${COLOR.red}Error: '${resolvedDir}' is not a directory.${COLOR.reset}`,
      );
      process.exit(1);
    }

    const glob = new Glob("**/*.json");
    const dirMap = new Map<string, string[]>();

    for await (const file of glob.scan(resolvedDir)) {
      const dir = path.dirname(file);
      dirMap.set(dir, [...(dirMap.get(dir) || []), file]);
    }

    if (dirMap.size === 0) {
      console.log(
        `${COLOR.yellow}No files found matching the glob pattern '**/*.json' in directory '${resolvedDir}'.${COLOR.reset}`,
      );
      return;
    }

    let conversionHappened = false;

    for (const [dir, files] of dirMap) {
      let directoryPrinted = false;

      for (const file of files) {
        try {
          const filePath = path.join(resolvedDir, file);
          const jsonContent = await Bun.file(filePath).json();

          if (!isDeepgramTranscript(jsonContent)) {
            continue;
          }

          const srtPath = filePath.replace(/\.json$/, ".srt");
          if (!directoryPrinted) {
            console.log(`${COLOR.cyan}📁 ${dir}${COLOR.reset}`);
            directoryPrinted = true;
          }

          const srtContent = srt(jsonContent);
          await Bun.write(srtPath, srtContent);
          console.log(
            `  ${COLOR.green}→${COLOR.reset} ${path.basename(file)} → ${path.basename(
              srtPath,
            )}`,
          );
          conversionHappened = true;
        } catch (error) {
          if (error instanceof SyntaxError) {
            continue;
          } else {
            console.error(
              `  ${COLOR.red}✗${COLOR.reset} Error processing ${path.basename(
                file,
              )}: ${error.message}`,
            );
          }
        }
      }
    }

    if (!conversionHappened) {
      console.log(
        `${COLOR.yellow}No Deepgram JSON files converted to SRT.${COLOR.reset}`,
      );
    } else {
      console.log(
        `${COLOR.green}✅ All conversions completed successfully${COLOR.reset}`,
      );
    }
  } catch (error) {
    console.error(
      `${COLOR.red}🚨 Critical error: ${error.message}${COLOR.reset}`,
    );
    process.exit(1);
  }
}

await processFiles();

// Type definitions for Deepgram response
interface DeepgramSchema {
  metadata: {
    transaction_key: string;
    request_id: string;
    sha256: string;
    created: string;
    duration: number;
    channels: number;
    models: string[];
    model_info: Record<string, { name: string; version: string; arch: string }>;
  };
  results: {
    channels: {
      alternatives: {
        transcript: string;
        confidence: number;
        words: {
          word: string;
          start: number;
          end: number;
          confidence: number;
          punctuated_word?: string;
        }[];
      }[];
    }[];
  };
}

So I guess some APIs, I should use Node for & for some Bun. I thought the LLM couldn't find latest docs but it was right.