@org-press/fmt 0.9.12

package/LICENSE

@@ -0,0 +1,29 @@
+GNU GENERAL PUBLIC LICENSE
+Version 2, June 1991
+
+Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+For the full license text, see: https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+
+---
+
+Org-Press - Static site generator for org-mode files
+Copyright (C) 2024-2026
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

package/dist/index.js

@@ -0,0 +1,361 @@
+// src/plugin.ts
+import { CreateCommand } from "org-press";
+
+// src/command.ts
+import * as prettier from "prettier";
+
+// src/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import { pathToFileURL } from "url";
+import { parse } from "uniorg-parse/lib/parser.js";
+function findOrgFiles(dir) {
+  const files = [];
+  if (!fs.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+        files.push(...findOrgFiles(fullPath));
+      }
+    } else if (entry.name.endsWith(".org")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function extractBlocksFromFile(orgFilePath, projectRoot, options) {
+  const absolutePath = path.isAbsolute(orgFilePath) ? orgFilePath : path.join(projectRoot, orgFilePath);
+  const relativePath = path.relative(projectRoot, absolutePath);
+  const content = fs.readFileSync(absolutePath, "utf-8");
+  const lines = content.split("\n");
+  const ast = parse(content);
+  const blocks = [];
+  let blockIndex = 0;
+  const blockPositions = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const beginMatch = line.match(/^\s*#\+begin_src\s+(\w+)(.*)$/i);
+    if (beginMatch) {
+      const language = beginMatch[1].toLowerCase();
+      let name;
+      for (let j = i - 1; j >= 0; j--) {
+        const prevLine = lines[j].trim();
+        const nameMatch = prevLine.match(/^#\+name:\s*(.+)$/i);
+        if (nameMatch) {
+          name = nameMatch[1].trim();
+          break;
+        }
+        if (prevLine && !prevLine.startsWith("#")) break;
+      }
+      let endLine = i;
+      for (let k = i + 1; k < lines.length; k++) {
+        if (lines[k].match(/^\s*#\+end_src\s*$/i)) {
+          endLine = k;
+          break;
+        }
+      }
+      blockPositions.push({
+        startLine: i + 1,
+        // 1-based
+        endLine: endLine + 1,
+        // 1-based
+        name,
+        language
+      });
+    }
+  }
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    const nodeObj = node;
+    if (nodeObj.type === "src-block") {
+      const position = blockPositions[blockIndex];
+      if (!position) {
+        blockIndex++;
+        return;
+      }
+      const language = nodeObj.language?.toLowerCase() || "";
+      if (options?.languages && options.languages.length > 0 && !options.languages.includes(language)) {
+        blockIndex++;
+        return;
+      }
+      blocks.push({
+        orgFilePath: relativePath,
+        blockIndex,
+        blockName: position.name,
+        code: nodeObj.value || "",
+        language,
+        startLine: position.startLine,
+        endLine: position.endLine
+      });
+      blockIndex++;
+    }
+    if (nodeObj.children && Array.isArray(nodeObj.children)) {
+      for (const child of nodeObj.children) {
+        walk(child);
+      }
+    }
+  }
+  walk(ast);
+  return blocks;
+}
+async function collectCodeBlocks(contentDir, projectRoot = process.cwd(), options) {
+  const absoluteContentDir = path.isAbsolute(contentDir) ? contentDir : path.join(projectRoot, contentDir);
+  let orgFiles = findOrgFiles(absoluteContentDir);
+  if (options?.files && options.files.length > 0) {
+    const patterns = options.files.map(
+      (f) => path.isAbsolute(f) ? f : path.join(projectRoot, f)
+    );
+    orgFiles = orgFiles.filter(
+      (file) => patterns.some((pattern) => {
+        if (pattern.endsWith(".org")) {
+          return file === pattern || file.endsWith(pattern);
+        }
+        return file.includes(pattern);
+      })
+    );
+  }
+  const allBlocks = [];
+  for (const orgFile of orgFiles) {
+    try {
+      const blocks = extractBlocksFromFile(orgFile, projectRoot, options);
+      allBlocks.push(...blocks);
+    } catch (error) {
+      console.warn(
+        `[fmt] Warning: Failed to parse ${orgFile}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return allBlocks;
+}
+function writeBlockContentBatch(updates, projectRoot = process.cwd()) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const update of updates) {
+    const filePath = update.block.orgFilePath;
+    if (!byFile.has(filePath)) {
+      byFile.set(filePath, []);
+    }
+    byFile.get(filePath).push(update);
+  }
+  for (const [filePath, fileUpdates] of byFile) {
+    fileUpdates.sort((a, b) => b.block.blockIndex - a.block.blockIndex);
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(projectRoot, filePath);
+    let fileContent = fs.readFileSync(absolutePath, "utf-8");
+    let lines = fileContent.split("\n");
+    for (const { block, newContent } of fileUpdates) {
+      const beginLineIndex = block.startLine - 1;
+      const endLineIndex = block.endLine - 1;
+      if (beginLineIndex < 0 || endLineIndex >= lines.length || beginLineIndex >= endLineIndex) {
+        console.warn(
+          `[fmt] Warning: Invalid block position in ${filePath}: lines ${block.startLine}-${block.endLine}`
+        );
+        continue;
+      }
+      const beginLine = lines[beginLineIndex];
+      const endLine = lines[endLineIndex];
+      if (!beginLine.match(/^\s*#\+begin_src\s+\w+/i)) {
+        console.warn(
+          `[fmt] Warning: Expected #+begin_src at line ${block.startLine} in ${filePath}`
+        );
+        continue;
+      }
+      if (!endLine.match(/^\s*#\+end_src\s*$/i)) {
+        console.warn(
+          `[fmt] Warning: Expected #+end_src at line ${block.endLine} in ${filePath}`
+        );
+        continue;
+      }
+      const trimmedContent = newContent.replace(/\n$/, "");
+      const beforeBlock = lines.slice(0, beginLineIndex + 1);
+      const afterBlock = lines.slice(endLineIndex);
+      lines = [...beforeBlock, trimmedContent, ...afterBlock];
+    }
+    fs.writeFileSync(absolutePath, lines.join("\n"), "utf-8");
+  }
+}
+async function loadPrettierConfig(projectRoot) {
+  const configFiles = [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.mjs",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs"
+  ];
+  for (const configFile of configFiles) {
+    const configPath = path.join(projectRoot, configFile);
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+    try {
+      if (configFile.endsWith(".json") || configFile === ".prettierrc") {
+        const content = fs.readFileSync(configPath, "utf-8");
+        return JSON.parse(content);
+      }
+      if (configFile.endsWith(".js") || configFile.endsWith(".cjs") || configFile.endsWith(".mjs")) {
+        const configUrl = pathToFileURL(configPath).href;
+        const module = await import(configUrl);
+        return module.default || module;
+      }
+    } catch (error) {
+      console.warn(
+        `[fmt] Warning: Failed to load ${configFile}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return {};
+}
+
+// src/types.ts
+var PRETTIER_PARSERS = {
+  typescript: "typescript",
+  ts: "typescript",
+  tsx: "typescript",
+  javascript: "babel",
+  js: "babel",
+  jsx: "babel",
+  json: "json",
+  css: "css",
+  scss: "scss",
+  less: "less",
+  html: "html",
+  yaml: "yaml",
+  yml: "yaml",
+  markdown: "markdown",
+  md: "markdown",
+  graphql: "graphql",
+  gql: "graphql"
+};
+
+// src/command.ts
+function parseFmtArgs(args) {
+  const options = {
+    check: false,
+    write: true,
+    languages: [],
+    files: []
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--check" || arg === "-c") {
+      options.check = true;
+      options.write = false;
+    } else if (arg === "--write" || arg === "-w") {
+      options.write = true;
+    } else if (arg === "--languages" || arg === "-l") {
+      const next = args[++i];
+      if (next) {
+        options.languages = next.split(",").map((l) => l.trim().toLowerCase());
+      }
+    } else if (!arg.startsWith("-")) {
+      options.files.push(arg);
+    }
+  }
+  return options;
+}
+function getParserForLanguage(language) {
+  return PRETTIER_PARSERS[language.toLowerCase()] || null;
+}
+async function runFmt(args, ctx) {
+  const options = parseFmtArgs(args);
+  const prettierConfig = await loadPrettierConfig(ctx.projectRoot);
+  const collectOptions = {
+    files: options.files?.length ? options.files : void 0,
+    languages: options.languages?.length ? options.languages : void 0
+  };
+  const blocks = await collectCodeBlocks(
+    ctx.contentDir,
+    ctx.projectRoot,
+    collectOptions
+  );
+  if (blocks.length === 0) {
+    console.log("[fmt] No code blocks found to format");
+    return 0;
+  }
+  let changedCount = 0;
+  let skippedCount = 0;
+  const updates = [];
+  for (const block of blocks) {
+    const parser = getParserForLanguage(block.language);
+    if (!parser) {
+      skippedCount++;
+      continue;
+    }
+    try {
+      const formatted2 = await prettier.format(block.code, {
+        parser,
+        ...prettierConfig
+      });
+      const normalizedFormatted = formatted2.replace(/\n$/, "");
+      const normalizedOriginal = block.code.replace(/\n$/, "");
+      if (normalizedFormatted !== normalizedOriginal) {
+        changedCount++;
+        if (options.check) {
+          const location = block.blockName ? `${block.orgFilePath}:${block.startLine} (${block.blockName})` : `${block.orgFilePath}:${block.startLine}`;
+          console.log(`[fmt] Would format: ${location}`);
+        } else {
+          updates.push({ block, newContent: normalizedFormatted });
+        }
+      }
+    } catch (error) {
+      const location = block.blockName ? `${block.orgFilePath}:${block.startLine} (${block.blockName})` : `${block.orgFilePath}:${block.startLine}`;
+      console.warn(
+        `[fmt] Warning: Failed to format ${location}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (!options.check && updates.length > 0) {
+    writeBlockContentBatch(updates, ctx.projectRoot);
+  }
+  const total = blocks.length;
+  const formatted = options.check ? 0 : changedCount;
+  const unchanged = total - changedCount - skippedCount;
+  if (options.check) {
+    if (changedCount > 0) {
+      console.log(
+        `[fmt] ${changedCount} block(s) need formatting (${unchanged} unchanged, ${skippedCount} skipped)`
+      );
+      return 1;
+    } else {
+      console.log(
+        `[fmt] All ${unchanged} block(s) are formatted (${skippedCount} skipped)`
+      );
+      return 0;
+    }
+  } else {
+    if (formatted > 0) {
+      console.log(
+        `[fmt] Formatted ${formatted} block(s) (${unchanged} unchanged, ${skippedCount} skipped)`
+      );
+    } else {
+      console.log(
+        `[fmt] All ${unchanged} block(s) are formatted (${skippedCount} skipped)`
+      );
+    }
+    return 0;
+  }
+}
+
+// src/plugin.ts
+var fmtPlugin = CreateCommand("fmt", {
+  description: "Format code blocks in org files using Prettier",
+  args: [
+    { name: "check", type: "boolean", description: "Check if files are formatted" },
+    { name: "languages", type: "string", description: "Comma-separated list of languages" }
+  ],
+  execute: (args, ctx) => runFmt(args._, ctx)
+});
+export {
+  PRETTIER_PARSERS,
+  collectCodeBlocks,
+  fmtPlugin,
+  loadPrettierConfig,
+  parseFmtArgs,
+  runFmt,
+  writeBlockContentBatch
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@org-press/fmt",
+  "version": "0.9.12",
+  "description": "Format code blocks in org files using Prettier",
+  "license": "GPL-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "org-press": ">=0.9.0"
+  },
+  "dependencies": {
+    "prettier": "^3.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "~5.7.3",
+    "uniorg": "^1.3.0",
+    "uniorg-parse": "^3.2.0",
+    "@types/node": "^20.0.0",
+    "org-press": "0.9.13"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://orgp.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/org-press/org-press.git"
+  },
+  "bugs": {
+    "url": "https://github.com/org-press/org-press/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  }
+}

package/src/command.ts

@@ -0,0 +1,163 @@
+/**
+ * Format Command Implementation
+ *
+ * Formats code blocks in org files using Prettier.
+ */
+
+import * as prettier from "prettier";
+import type { CommandContext } from "org-press";
+import { collectCodeBlocks, writeBlockContentBatch, loadPrettierConfig } from "./utils.js";
+import { PRETTIER_PARSERS, type FmtOptions } from "./types.js";
+
+/**
+ * Parse command line arguments for fmt command
+ */
+export function parseFmtArgs(args: string[]): FmtOptions {
+  const options: FmtOptions = {
+    check: false,
+    write: true,
+    languages: [],
+    files: [],
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === "--check" || arg === "-c") {
+      options.check = true;
+      options.write = false;
+    } else if (arg === "--write" || arg === "-w") {
+      options.write = true;
+    } else if (arg === "--languages" || arg === "-l") {
+      const next = args[++i];
+      if (next) {
+        options.languages = next.split(",").map((l) => l.trim().toLowerCase());
+      }
+    } else if (!arg.startsWith("-")) {
+      // Positional argument - file pattern
+      options.files!.push(arg);
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Get Prettier parser for a language
+ */
+function getParserForLanguage(language: string): string | null {
+  return PRETTIER_PARSERS[language.toLowerCase()] || null;
+}
+
+/**
+ * Run the format command
+ *
+ * @param args - Command line arguments
+ * @param ctx - CLI context
+ * @returns Exit code (0 for success, 1 if check found changes)
+ */
+export async function runFmt(
+  args: string[],
+  ctx: CommandContext
+): Promise<number> {
+  const options = parseFmtArgs(args);
+  const prettierConfig = await loadPrettierConfig(ctx.projectRoot);
+
+  // Collect blocks, filtering by language if formatting specific languages
+  const collectOptions = {
+    files: options.files?.length ? options.files : undefined,
+    languages: options.languages?.length ? options.languages : undefined,
+  };
+
+  const blocks = await collectCodeBlocks(
+    ctx.contentDir,
+    ctx.projectRoot,
+    collectOptions
+  );
+
+  if (blocks.length === 0) {
+    console.log("[fmt] No code blocks found to format");
+    return 0;
+  }
+
+  let changedCount = 0;
+  let skippedCount = 0;
+  const updates: Array<{ block: (typeof blocks)[0]; newContent: string }> = [];
+
+  for (const block of blocks) {
+    const parser = getParserForLanguage(block.language);
+
+    if (!parser) {
+      skippedCount++;
+      continue;
+    }
+
+    try {
+      const formatted = await prettier.format(block.code, {
+        parser,
+        ...prettierConfig,
+      });
+
+      // Prettier adds trailing newline, but we store without it
+      const normalizedFormatted = formatted.replace(/\n$/, "");
+      const normalizedOriginal = block.code.replace(/\n$/, "");
+
+      if (normalizedFormatted !== normalizedOriginal) {
+        changedCount++;
+
+        if (options.check) {
+          const location = block.blockName
+            ? `${block.orgFilePath}:${block.startLine} (${block.blockName})`
+            : `${block.orgFilePath}:${block.startLine}`;
+          console.log(`[fmt] Would format: ${location}`);
+        } else {
+          updates.push({ block, newContent: normalizedFormatted });
+        }
+      }
+    } catch (error) {
+      const location = block.blockName
+        ? `${block.orgFilePath}:${block.startLine} (${block.blockName})`
+        : `${block.orgFilePath}:${block.startLine}`;
+      console.warn(
+        `[fmt] Warning: Failed to format ${location}: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
+  // Write changes if not in check mode
+  if (!options.check && updates.length > 0) {
+    writeBlockContentBatch(updates, ctx.projectRoot);
+  }
+
+  // Summary
+  const total = blocks.length;
+  const formatted = options.check ? 0 : changedCount;
+  const unchanged = total - changedCount - skippedCount;
+
+  if (options.check) {
+    if (changedCount > 0) {
+      console.log(
+        `[fmt] ${changedCount} block(s) need formatting (${unchanged} unchanged, ${skippedCount} skipped)`
+      );
+      return 1;
+    } else {
+      console.log(
+        `[fmt] All ${unchanged} block(s) are formatted (${skippedCount} skipped)`
+      );
+      return 0;
+    }
+  } else {
+    if (formatted > 0) {
+      console.log(
+        `[fmt] Formatted ${formatted} block(s) (${unchanged} unchanged, ${skippedCount} skipped)`
+      );
+    } else {
+      console.log(
+        `[fmt] All ${unchanged} block(s) are formatted (${skippedCount} skipped)`
+      );
+    }
+    return 0;
+  }
+}

package/src/index.ts

@@ -0,0 +1,33 @@
+/**
+ * @org-press/fmt
+ *
+ * Format code blocks in org files using Prettier.
+ *
+ * This package provides the `orgp fmt` CLI command plugin.
+ *
+ * @example
+ * ```typescript
+ * // .org-press/config.ts
+ * import { fmtPlugin } from '@org-press/fmt';
+ *
+ * export default {
+ *   contentDir: 'content',
+ *   plugins: [fmtPlugin],
+ * };
+ * ```
+ */
+
+// Plugin export
+export { fmtPlugin } from "./plugin.js";
+
+// Command export (for programmatic use)
+export { runFmt, parseFmtArgs } from "./command.js";
+
+// Type exports
+export type { CollectedBlock, CollectOptions, FmtOptions } from "./types.js";
+
+// Constant exports
+export { PRETTIER_PARSERS } from "./types.js";
+
+// Utility exports (for advanced use cases)
+export { collectCodeBlocks, writeBlockContentBatch, loadPrettierConfig } from "./utils.js";

package/src/plugin.ts

@@ -0,0 +1,30 @@
+/**
+ * Format Plugin
+ *
+ * Provides the `orgp fmt` command for formatting code blocks with Prettier.
+ */
+
+import { CreateCommand } from "org-press";
+import type { ParsedArgs, CommandContext } from "org-press";
+import { runFmt } from "./command.js";
+
+/**
+ * Format plugin
+ *
+ * Registers the `fmt` CLI command for formatting code blocks
+ * in org files using Prettier.
+ *
+ * Usage:
+ *   orgp fmt                      # Format all blocks
+ *   orgp fmt --check              # Check if blocks are formatted
+ *   orgp fmt --languages ts,tsx   # Format only TypeScript blocks
+ *   orgp fmt content/api.org      # Format specific file
+ */
+export const fmtPlugin = CreateCommand("fmt", {
+  description: "Format code blocks in org files using Prettier",
+  args: [
+    { name: "check", type: "boolean", description: "Check if files are formatted" },
+    { name: "languages", type: "string", description: "Comma-separated list of languages" },
+  ],
+  execute: (args: ParsedArgs, ctx: CommandContext) => runFmt(args._, ctx),
+});

package/src/types.ts

@@ -0,0 +1,70 @@
+/**
+ * Types for @org-press/fmt
+ */
+
+/**
+ * A collected code block from an org file
+ */
+export interface CollectedBlock {
+  /** Relative path to the org file */
+  orgFilePath: string;
+  /** 0-based index of the block in the file */
+  blockIndex: number;
+  /** Block name from #+NAME: directive */
+  blockName?: string;
+  /** The source code content */
+  code: string;
+  /** Block language (e.g., "typescript", "javascript") */
+  language: string;
+  /** 1-based line number where the block starts (#+begin_src line) */
+  startLine: number;
+  /** 1-based line number where the block ends (#+end_src line) */
+  endLine: number;
+}
+
+/**
+ * Options for collecting code blocks
+ */
+export interface CollectOptions {
+  /** Filter by file path patterns */
+  files?: string[];
+  /** Filter by languages */
+  languages?: string[];
+}
+
+/**
+ * Options for the format command
+ */
+export interface FmtOptions {
+  /** Check only, don't write changes */
+  check?: boolean;
+  /** Write changes (default: true when not checking) */
+  write?: boolean;
+  /** Filter by languages */
+  languages?: string[];
+  /** Filter by file patterns */
+  files?: string[];
+}
+
+/**
+ * Language to Prettier parser mapping
+ */
+export const PRETTIER_PARSERS: Record<string, string> = {
+  typescript: "typescript",
+  ts: "typescript",
+  tsx: "typescript",
+  javascript: "babel",
+  js: "babel",
+  jsx: "babel",
+  json: "json",
+  css: "css",
+  scss: "scss",
+  less: "less",
+  html: "html",
+  yaml: "yaml",
+  yml: "yaml",
+  markdown: "markdown",
+  md: "markdown",
+  graphql: "graphql",
+  gql: "graphql",
+};

package/src/utils.ts

@@ -0,0 +1,358 @@
+/**
+ * Utilities for @org-press/fmt
+ *
+ * Block collection, writing, and config loading functions.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { parse } from "uniorg-parse/lib/parser.js";
+import type { OrgData } from "uniorg";
+import type { Options as PrettierOptions } from "prettier";
+import type { CollectedBlock, CollectOptions } from "./types.js";
+
+/**
+ * Find all org files recursively in a directory
+ */
+function findOrgFiles(dir: string): string[] {
+  const files: string[] = [];
+
+  if (!fs.existsSync(dir)) {
+    return files;
+  }
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      // Skip node_modules and hidden directories
+      if (entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+        files.push(...findOrgFiles(fullPath));
+      }
+    } else if (entry.name.endsWith(".org")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Extract code blocks from a single org file
+ */
+function extractBlocksFromFile(
+  orgFilePath: string,
+  projectRoot: string,
+  options?: CollectOptions
+): CollectedBlock[] {
+  const absolutePath = path.isAbsolute(orgFilePath)
+    ? orgFilePath
+    : path.join(projectRoot, orgFilePath);
+  const relativePath = path.relative(projectRoot, absolutePath);
+  const content = fs.readFileSync(absolutePath, "utf-8");
+  const lines = content.split("\n");
+  const ast = parse(content) as OrgData;
+
+  const blocks: CollectedBlock[] = [];
+  let blockIndex = 0;
+
+  // Find block positions and names by scanning raw content
+  const blockPositions: Array<{
+    startLine: number;
+    endLine: number;
+    name?: string;
+    language: string;
+  }> = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const beginMatch = line.match(/^\s*#\+begin_src\s+(\w+)(.*)$/i);
+
+    if (beginMatch) {
+      const language = beginMatch[1].toLowerCase();
+
+      // Look backwards for #+NAME: directive
+      let name: string | undefined;
+      for (let j = i - 1; j >= 0; j--) {
+        const prevLine = lines[j].trim();
+        const nameMatch = prevLine.match(/^#\+name:\s*(.+)$/i);
+        if (nameMatch) {
+          name = nameMatch[1].trim();
+          break;
+        }
+        // Stop looking if we hit a non-comment, non-empty line
+        if (prevLine && !prevLine.startsWith("#")) break;
+      }
+
+      // Find matching #+end_src
+      let endLine = i;
+      for (let k = i + 1; k < lines.length; k++) {
+        if (lines[k].match(/^\s*#\+end_src\s*$/i)) {
+          endLine = k;
+          break;
+        }
+      }
+
+      blockPositions.push({
+        startLine: i + 1, // 1-based
+        endLine: endLine + 1, // 1-based
+        name,
+        language,
+      });
+    }
+  }
+
+  // Walk AST and match blocks with their positions
+  function walk(node: unknown): void {
+    if (!node || typeof node !== "object") return;
+
+    const nodeObj = node as Record<string, unknown>;
+
+    if (nodeObj.type === "src-block") {
+      const position = blockPositions[blockIndex];
+      if (!position) {
+        blockIndex++;
+        return;
+      }
+
+      const language = (nodeObj.language as string)?.toLowerCase() || "";
+
+      // Filter by language if specified
+      if (
+        options?.languages &&
+        options.languages.length > 0 &&
+        !options.languages.includes(language)
+      ) {
+        blockIndex++;
+        return;
+      }
+
+      blocks.push({
+        orgFilePath: relativePath,
+        blockIndex,
+        blockName: position.name,
+        code: (nodeObj.value as string) || "",
+        language,
+        startLine: position.startLine,
+        endLine: position.endLine,
+      });
+
+      blockIndex++;
+    }
+
+    // Recurse into children
+    if (nodeObj.children && Array.isArray(nodeObj.children)) {
+      for (const child of nodeObj.children) {
+        walk(child);
+      }
+    }
+  }
+
+  walk(ast);
+  return blocks;
+}
+
+/**
+ * Collect all code blocks from a content directory
+ *
+ * @param contentDir - Content directory to scan
+ * @param projectRoot - Project root directory
+ * @param options - Collection options
+ * @returns Array of collected code blocks
+ */
+export async function collectCodeBlocks(
+  contentDir: string,
+  projectRoot: string = process.cwd(),
+  options?: CollectOptions
+): Promise<CollectedBlock[]> {
+  const absoluteContentDir = path.isAbsolute(contentDir)
+    ? contentDir
+    : path.join(projectRoot, contentDir);
+
+  // Find all org files
+  let orgFiles = findOrgFiles(absoluteContentDir);
+
+  // Filter by file patterns if specified
+  if (options?.files && options.files.length > 0) {
+    const patterns = options.files.map((f) =>
+      path.isAbsolute(f) ? f : path.join(projectRoot, f)
+    );
+
+    orgFiles = orgFiles.filter((file) =>
+      patterns.some((pattern) => {
+        // Support both exact match and contains match
+        if (pattern.endsWith(".org")) {
+          return file === pattern || file.endsWith(pattern);
+        }
+        return file.includes(pattern);
+      })
+    );
+  }
+
+  const allBlocks: CollectedBlock[] = [];
+
+  // Process each file
+  for (const orgFile of orgFiles) {
+    try {
+      const blocks = extractBlocksFromFile(orgFile, projectRoot, options);
+      allBlocks.push(...blocks);
+    } catch (error) {
+      console.warn(
+        `[fmt] Warning: Failed to parse ${orgFile}: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
+  return allBlocks;
+}
+
+/**
+ * Batch write multiple block updates to minimize file I/O
+ *
+ * Updates are grouped by file and applied in reverse order
+ * (to preserve line numbers for earlier blocks in the same file)
+ *
+ * @param updates - Array of {block, newContent} pairs
+ * @param projectRoot - Project root directory
+ */
+export function writeBlockContentBatch(
+  updates: Array<{ block: CollectedBlock; newContent: string }>,
+  projectRoot: string = process.cwd()
+): void {
+  // Group updates by file
+  const byFile = new Map<string, Array<{ block: CollectedBlock; newContent: string }>>();
+
+  for (const update of updates) {
+    const filePath = update.block.orgFilePath;
+    if (!byFile.has(filePath)) {
+      byFile.set(filePath, []);
+    }
+    byFile.get(filePath)!.push(update);
+  }
+
+  // Process each file
+  for (const [filePath, fileUpdates] of byFile) {
+    // Sort by blockIndex in reverse order so we can apply changes
+    // from the end of the file backwards (preserving line numbers)
+    fileUpdates.sort((a, b) => b.block.blockIndex - a.block.blockIndex);
+
+    const absolutePath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(projectRoot, filePath);
+
+    let fileContent = fs.readFileSync(absolutePath, "utf-8");
+    let lines = fileContent.split("\n");
+
+    for (const { block, newContent } of fileUpdates) {
+      const beginLineIndex = block.startLine - 1;
+      const endLineIndex = block.endLine - 1;
+
+      // Validate
+      if (
+        beginLineIndex < 0 ||
+        endLineIndex >= lines.length ||
+        beginLineIndex >= endLineIndex
+      ) {
+        console.warn(
+          `[fmt] Warning: Invalid block position in ${filePath}: lines ${block.startLine}-${block.endLine}`
+        );
+        continue;
+      }
+
+      const beginLine = lines[beginLineIndex];
+      const endLine = lines[endLineIndex];
+
+      if (!beginLine.match(/^\s*#\+begin_src\s+\w+/i)) {
+        console.warn(
+          `[fmt] Warning: Expected #+begin_src at line ${block.startLine} in ${filePath}`
+        );
+        continue;
+      }
+
+      if (!endLine.match(/^\s*#\+end_src\s*$/i)) {
+        console.warn(
+          `[fmt] Warning: Expected #+end_src at line ${block.endLine} in ${filePath}`
+        );
+        continue;
+      }
+
+      // Replace content
+      const trimmedContent = newContent.replace(/\n$/, "");
+      const beforeBlock = lines.slice(0, beginLineIndex + 1);
+      const afterBlock = lines.slice(endLineIndex);
+      lines = [...beforeBlock, trimmedContent, ...afterBlock];
+    }
+
+    fs.writeFileSync(absolutePath, lines.join("\n"), "utf-8");
+  }
+}
+
+/**
+ * Load Prettier configuration from the project root
+ *
+ * Searches for:
+ * - .prettierrc
+ * - .prettierrc.json
+ * - .prettierrc.js
+ * - .prettierrc.cjs
+ * - .prettierrc.mjs
+ * - prettier.config.js
+ * - prettier.config.cjs
+ * - prettier.config.mjs
+ *
+ * @param projectRoot - Project root directory
+ * @returns Prettier options or empty object if not found
+ */
+export async function loadPrettierConfig(
+  projectRoot: string
+): Promise<PrettierOptions> {
+  const configFiles = [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.mjs",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs",
+  ];
+
+  for (const configFile of configFiles) {
+    const configPath = path.join(projectRoot, configFile);
+
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+
+    try {
+      if (configFile.endsWith(".json") || configFile === ".prettierrc") {
+        const content = fs.readFileSync(configPath, "utf-8");
+        return JSON.parse(content) as PrettierOptions;
+      }
+
+      if (
+        configFile.endsWith(".js") ||
+        configFile.endsWith(".cjs") ||
+        configFile.endsWith(".mjs")
+      ) {
+        const configUrl = pathToFileURL(configPath).href;
+        const module = await import(configUrl);
+        return (module.default || module) as PrettierOptions;
+      }
+    } catch (error) {
+      console.warn(
+        `[fmt] Warning: Failed to load ${configFile}: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
+  // Return default options if no config found
+  return {};
+}