block-in-file 1.0.0

package/src/file-processor.ts

@@ -0,0 +1,378 @@
+import type { ModeArg, EnvsubstMode } from "./plugins/config.ts";
+import type { LoggerExtension } from "./plugins/logger.ts";
+import type { IOExtension } from "./plugins/io.ts";
+import type { DiffExtension } from "./plugins/diff.ts";
+import type { BackupOptions } from "./backup.ts";
+import { parseAndInsertBlock } from "./block-parser.ts";
+import { formatOutputs } from "./output.ts";
+import { detectBlockState, shouldSkipForMode } from "./mode-handler.ts";
+import { runValidation } from "./validation.ts";
+import { detectConflicts, detectConflictsWithPattern } from "./conflict-detection.ts";
+import { parseAttributes, applyAttributesSafe } from "./attributes.ts";
+import { removeBlocks, type RemovalStats } from "./block-remover.ts";
+import { substitute } from "./envsubst.ts";
+import { generateTimestampTag, parseTimestampFormat } from "./timestamp.ts";
+import { stripTagsForMatching, addTags, parseTags, type Tag } from "./tags/tags.ts";
+import { applyTagMode } from "./tags/tag-merger.ts";
+import type { TagMode } from "./tags/tag-mode.ts";
+
+export interface ProcessContext {
+  file: string;
+  fileExists: boolean;
+  fileContent: string;
+  inputBlock: string;
+  opener: string;
+  closer: string;
+  before?: RegExp | boolean;
+  after?: RegExp | boolean;
+  mode?: ModeArg;
+  force?: boolean;
+  create?: boolean;
+  validateCmd?: string;
+  debug: boolean;
+  logger: LoggerExtension;
+  io: IOExtension;
+  diffExt: DiffExtension;
+  output: string;
+  dos: boolean;
+  backupOptions?: BackupOptions;
+  tempExt?: string;
+  tempExtAtomic?: string;
+  tempExtPrevalidate?: string;
+  appendNewline?: boolean;
+  attributes?: string;
+  removeAll?: string;
+  removeOrphans?: boolean;
+  envsubst?: EnvsubstMode;
+  additive?: boolean;
+  additiveBefore?: string;
+  additiveAfter?: string;
+  timestamp?: string;
+  tagMode?: string;
+}
+
+export interface ProcessResult {
+  status: "written" | "skipped" | "validation-failed" | "removed";
+  reason?: string;
+  outputs?: string[];
+  originalContent?: string;
+  removalStats?: RemovalStats;
+}
+
+export async function processFile(ctx: ProcessContext): Promise<ProcessResult> {
+  const {
+    file,
+    fileContent,
+    opener,
+    closer,
+    inputBlock,
+    before,
+    after,
+    mode,
+    force,
+    validateCmd,
+    debug,
+    logger,
+    io,
+    diffExt: _diffExt,
+    output,
+    dos,
+    backupOptions,
+    create,
+    tempExt,
+    tempExtAtomic,
+    tempExtPrevalidate,
+    appendNewline,
+    attributes,
+    removeAll,
+    removeOrphans,
+    envsubst,
+    additive,
+    additiveBefore,
+    additiveAfter,
+    timestamp,
+    tagMode,
+  } = ctx;
+
+  const processedInputBlock = envsubst ? substitute(inputBlock, { mode: envsubst }) : inputBlock;
+
+  if (debug) {
+    logger.debug(`Processing file: ${file}`);
+  }
+
+  if (additiveBefore && additiveAfter) {
+    throw new Error("Cannot specify both --additive-before and --additive-after");
+  }
+
+  let parsedAdditiveBefore: RegExp | "EOB" | "EOF" | "BOF" | undefined;
+  let parsedAdditiveAfter: RegExp | "EOB" | "EOF" | "BOF" | undefined;
+
+  if (additiveBefore) {
+    if (additiveBefore === "EOB" || additiveBefore === "EOF" || additiveBefore === "BOF") {
+      parsedAdditiveBefore = additiveBefore;
+    } else {
+      parsedAdditiveBefore = new RegExp(additiveBefore);
+    }
+  }
+
+  if (additiveAfter) {
+    if (additiveAfter === "EOF" || additiveAfter === "EOB" || additiveAfter === "BOF") {
+      parsedAdditiveAfter = additiveAfter;
+    } else {
+      parsedAdditiveAfter = new RegExp(additiveAfter);
+    }
+  }
+
+  const timestampFormat = parseTimestampFormat(timestamp);
+
+  let parsedTagMode: TagMode = "merge";
+  if (tagMode) {
+    if (tagMode === "merge" || tagMode === "replace") {
+      parsedTagMode = tagMode;
+    }
+  }
+
+  let newTags: Tag[] = [];
+
+  if (timestampFormat) {
+    newTags.push({
+      name: "timestamp",
+      value: generateTimestampTag(timestampFormat)
+        .replace(/^\[timestamp:/, "")
+        .replace(/\]$/, ""),
+    });
+  }
+
+  let existingTags: Tag[] = [];
+  const lines = fileContent.split("\n");
+
+  for (const line of lines) {
+    const strippedLine = stripTagsForMatching(line.trim());
+    if (strippedLine === opener) {
+      existingTags = parseTags(line);
+      break;
+    }
+  }
+
+  const finalTags = applyTagMode(existingTags, newTags, parsedTagMode);
+
+  let actualOpener = opener;
+  let openerPattern: RegExp | undefined;
+  let closerPattern: RegExp | undefined;
+
+  if (finalTags.length > 0) {
+    actualOpener = addTags(opener, finalTags);
+
+    const openerBase = opener.replace(/\s+/g, "\\s+");
+    const closerBase = closer.replace(/\s+/g, "\\s+");
+    openerPattern = new RegExp(
+      `^\\s*${openerBase}(\\s+\\[[a-zA-Z0-9_-]+(?::[^\\[\\]]+)?\\])*\\s*$`,
+    );
+    closerPattern = new RegExp(`^\\s*${closerBase}\\s*$`);
+  }
+
+  const conflictResult =
+    finalTags.length > 0
+      ? detectConflictsWithPattern(
+          fileContent,
+          opener,
+          closer,
+          openerPattern!,
+          closerPattern!,
+          logger,
+        )
+      : detectConflicts(fileContent, opener, closer, logger);
+  if (conflictResult.hasConflicts) {
+    throw new Error(
+      `File conflicts detected:\n${conflictResult.conflicts.map((c) => c.message).join("\n")}`,
+    );
+  }
+
+  if (removeAll) {
+    const blockNames = removeAll
+      .trim()
+      .split(/\s+/)
+      .filter((n) => n.length > 0);
+
+    if (debug) {
+      logger.debug(`Removing blocks: ${blockNames.join(", ")}`);
+    }
+
+    const commentMatch = opener.match(/^(#\s*|\/\/\s*)/) || opener.match(/^(\/\/\s*)/);
+    const comment = commentMatch ? commentMatch[1] : "";
+    const openerParts = opener.split(/\s+/);
+    const closerParts = closer.split(/\s+/);
+    const markerStart = openerParts[openerParts.length - 1] || "start";
+    const markerEnd = closerParts[closerParts.length - 1] || "end";
+
+    const { content, stats } = removeBlocks({
+      fileContent,
+      blockNames,
+      comment,
+      markerStart,
+      markerEnd,
+      removeOrphans: removeOrphans || false,
+      debug,
+      logger,
+    });
+
+    let originalContent: string | undefined;
+    if (output === "---") {
+      originalContent = fileContent;
+      if (backupOptions && backupOptions.enabled) {
+        const backup = await io.backupFile(file, backupOptions, fileContent);
+        if (backup && debug) {
+          logger.debug(`Created backup: ${backup}`);
+        }
+      }
+    }
+
+    const outputText = formatOutputs([content], dos);
+
+    if (output === "---" || output === "--") {
+      let tempFile: string;
+
+      if (validateCmd && !force) {
+        const ext = tempExtPrevalidate || tempExt || ".prevalidate";
+        tempFile = `${file}${ext}`;
+        await io.writeFile(tempFile, outputText);
+        try {
+          await runValidation(tempFile, validateCmd);
+        } catch (err) {
+          await io.deleteFile(tempFile);
+          throw err;
+        }
+      } else {
+        const ext = tempExtAtomic || tempExt || ".atomic";
+        tempFile = `${file}${ext}`;
+        await io.writeFile(tempFile, outputText);
+      }
+
+      await io.rename(tempFile, file);
+
+      if (attributes) {
+        const changes = parseAttributes(attributes);
+        await applyAttributesSafe(file, changes, { debug, logger, io });
+      }
+    } else if (output === "-") {
+      io.writeFile(output, outputText);
+    } else {
+      await io.writeFile(output, outputText);
+    }
+
+    if (debug) {
+      logger.debug(`Removed ${stats.removed} block(s) (${stats.orphans} orphans) from ${file}`);
+    }
+
+    return { status: "removed", removalStats: stats, originalContent };
+  }
+
+  const blockExists = fileContent.includes(opener);
+  const wouldChange = blockWouldChange(fileContent, processedInputBlock, opener, closer);
+  const state = detectBlockState(ctx.fileExists, blockExists, wouldChange);
+
+  if (mode && mode !== "none") {
+    const decision = shouldSkipForMode(state, mode);
+    if (decision.skip) {
+      if (debug) {
+        logger.debug(`mode=${mode}: skipping, ${decision.reason}`);
+      }
+      return { status: "skipped", reason: decision.reason };
+    }
+  }
+
+  if (create && !ctx.fileExists) {
+    await io.writeFile(file, "");
+  } else if (before === true) {
+    await io.writeFile(file, "");
+  }
+
+  const result = parseAndInsertBlock(fileContent, {
+    opener: opener,
+    closer: closer,
+    inputBlock: processedInputBlock,
+    before: before === true ? undefined : before,
+    after: after === true ? undefined : after,
+    appendNewline,
+    additive,
+    additiveBefore: parsedAdditiveBefore,
+    additiveAfter: parsedAdditiveAfter,
+    actualOpener: finalTags.length > 0 ? actualOpener : undefined,
+  });
+
+  const outputText = formatOutputs(result.outputs, dos);
+  if (debug) {
+    logger.debug(`Output text length: ${outputText.length}`);
+  }
+
+  let originalContent: string | undefined;
+  if (output === "---") {
+    originalContent = fileContent;
+    if (backupOptions && backupOptions.enabled) {
+      const backup = await io.backupFile(file, backupOptions, fileContent);
+      if (backup && debug) {
+        logger.debug(`Created backup: ${backup}`);
+      }
+    }
+  }
+
+  if (output === "---" || output === "--") {
+    let tempFile: string;
+
+    if (validateCmd && !force) {
+      const ext = tempExtPrevalidate || tempExt || ".prevalidate";
+      tempFile = `${file}${ext}`;
+      await io.writeFile(tempFile, outputText);
+      try {
+        await runValidation(tempFile, validateCmd);
+      } catch (err) {
+        await io.deleteFile(tempFile);
+        throw err;
+      }
+    } else {
+      const ext = tempExtAtomic || tempExt || ".atomic";
+      tempFile = `${file}${ext}`;
+      await io.writeFile(tempFile, outputText);
+    }
+
+    await io.rename(tempFile, file);
+
+    if (attributes) {
+      const changes = parseAttributes(attributes);
+      await applyAttributesSafe(file, changes, { debug, logger, io });
+    }
+  } else if (output === "-") {
+    io.writeFile(output, outputText);
+  } else {
+    await io.writeFile(output, outputText);
+  }
+
+  if (debug) {
+    logger.debug(`Completed processing: ${file}`);
+  }
+
+  return { status: "written", outputs: result.outputs, originalContent };
+}
+
+function blockWouldChange(
+  fileContent: string,
+  inputBlock: string,
+  opener: string,
+  closer: string,
+): boolean {
+  const openerIndex = fileContent.indexOf(opener);
+  if (openerIndex === -1) {
+    return true;
+  }
+
+  const closerIndex = fileContent.indexOf(closer, openerIndex);
+  if (closerIndex === -1) {
+    return true;
+  }
+
+  const blockContent = fileContent.slice(openerIndex + opener.length, closerIndex);
+  const lines = blockContent.split("\n");
+  const content = lines.slice(1).join("\n");
+
+  return content.trim() !== inputBlock.trim();
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { defaultOptions, getDefaultOptions } from "./defaults.ts";
+export type { BlockInFileOptions, CreateArg, InputOptions, ParseResult } from "./types.ts";
+export { parseAndInsertBlock } from "./block-parser.ts";
+export { formatOutputs, generateDiff, writeDiff, writeOutput } from "./output.ts";
+export { createOpt, get, openInput, readInput } from "./input.ts";

package/src/input.ts

@@ -0,0 +1,69 @@
+import type { CreateArg, InputOptions } from "./types.ts";
+import * as fs from "node:fs/promises";
+
+export function get<T>(source: Partial<T>, defaults: Partial<T>, ...keys: (keyof T)[]) {
+  if (keys.length === 1) {
+    const key = keys[0];
+    const o = source[key];
+    return (o !== undefined ? o : defaults?.[key]) as any;
+  }
+
+  const o = Array.from({ length: keys.length });
+  for (const i in keys) {
+    o[i] = get(source, defaults, keys[i]);
+  }
+  return o;
+}
+
+export function createOpt(value: CreateArg, target: CreateArg): InputOptions | undefined {
+  return value === 1 || value === true || value === target ? { create: true } : undefined;
+}
+
+export async function openInput(file: string, opts?: InputOptions): Promise<fs.FileHandle> {
+  try {
+    if (file === "-" || file === undefined) {
+      return process.stdin as any;
+    }
+    return await fs.open(file, "r");
+  } catch (ex) {
+    if (opts?.create) {
+      return await fs.open("/dev/null", "r");
+    }
+    throw ex;
+  }
+}
+
+export async function readInput(file: string, opts?: InputOptions): Promise<string> {
+  const inputStream = await openInput(file, opts);
+  if (typeof inputStream === "object" && "readable" in inputStream) {
+    const reader = (inputStream.readable as ReadableStream<Uint8Array>).getReader();
+    const chunks: Uint8Array[] = [];
+
+    let done = false;
+    while (!done) {
+      const { value, done: isDone } = await reader.read();
+      done = isDone;
+      if (value) {
+        chunks.push(value);
+      }
+    }
+
+    const decoder = new TextDecoder();
+    return decoder.decode(concat(chunks));
+  }
+
+  throw new Error("Invalid input stream");
+}
+
+function concat(chunks: Uint8Array[]): Uint8Array {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+
+  return result;
+}

package/src/mode-handler.ts

@@ -0,0 +1,39 @@
+import type { ModeArg } from "./plugins/config.ts";
+
+export type BlockState = "absent" | "created" | "exists" | "updated" | "unchanged";
+
+export interface ProcessDecision {
+  skip: boolean;
+  reason?: string;
+}
+
+export function shouldSkipForMode(state: BlockState, mode: ModeArg): ProcessDecision {
+  if (mode === "only") {
+    if (state === "exists" || state === "updated") {
+      return { skip: true, reason: "block already exists" };
+    }
+  } else if (mode === "ensure") {
+    if (state === "unchanged") {
+      return { skip: true, reason: "no changes needed" };
+    }
+  }
+
+  return { skip: false };
+}
+
+export function detectBlockState(
+  fileExists: boolean,
+  hasBlock: boolean,
+  wouldChange: boolean,
+): BlockState {
+  if (!fileExists) {
+    return "absent";
+  }
+  if (!hasBlock) {
+    return "absent";
+  }
+  if (wouldChange) {
+    return "updated";
+  }
+  return "unchanged";
+}

package/src/output.ts

@@ -0,0 +1,107 @@
+import * as fs from "node:fs/promises";
+
+export function formatOutputs(outputs: string[], dos: boolean): string {
+  if (outputs.length === 0 || outputs[outputs.length - 1] !== "") {
+    outputs.push("");
+  }
+  return outputs.join(dos ? "\r\n" : "\n");
+}
+
+export async function writeOutput(
+  outputText: string,
+  output: string | undefined,
+  filePath: string,
+): Promise<void> {
+  if (!output || output === "---") {
+    await fs.writeFile(filePath, outputText, "utf-8");
+  } else if (output === "--") {
+    // no output
+  } else if (output === "-") {
+    console.log(outputText);
+  } else {
+    await fs.writeFile(output, outputText, "utf-8");
+  }
+}
+
+export function generateDiff(original: string, modified: string, filePath: string): string {
+  const originalLines = original.split("\n");
+  const modifiedLines = modified.split("\n");
+  const output: string[] = [];
+
+  output.push(`--- ${filePath}`);
+  output.push(`+++ ${filePath}`);
+
+  let i = 0;
+  let j = 0;
+
+  while (i < originalLines.length || j < modifiedLines.length) {
+    if (
+      i < originalLines.length &&
+      j < modifiedLines.length &&
+      originalLines[i] === modifiedLines[j]
+    ) {
+      output.push(` ${originalLines[i]}`);
+      i++;
+      j++;
+    } else {
+      const origStart = i;
+      const modStart = j;
+
+      while (
+        i < originalLines.length &&
+        (j >= modifiedLines.length || originalLines[i] !== modifiedLines[j])
+      ) {
+        let found = false;
+        for (let k = j; k < Math.min(j + 10, modifiedLines.length); k++) {
+          if (originalLines[i] === modifiedLines[k]) {
+            found = true;
+            break;
+          }
+        }
+        if (found) break;
+        i++;
+      }
+
+      while (
+        j < modifiedLines.length &&
+        (i >= originalLines.length || modifiedLines[j] !== originalLines[i])
+      ) {
+        let found = false;
+        for (let k = i; k < Math.min(i + 10, originalLines.length); k++) {
+          if (modifiedLines[j] === originalLines[k]) {
+            found = true;
+            break;
+          }
+        }
+        if (found) break;
+        j++;
+      }
+
+      for (let k = origStart; k < i; k++) {
+        output.push(`-${originalLines[k]}`);
+      }
+      for (let k = modStart; k < j; k++) {
+        output.push(`+${modifiedLines[k]}`);
+      }
+    }
+  }
+
+  return output.join("\n");
+}
+
+export async function writeDiff(
+  diff: string | boolean | undefined,
+  originalContent: string,
+  newContent: string,
+  filePath: string,
+): Promise<void> {
+  if (!diff) return;
+
+  const diffText = generateDiff(originalContent, newContent, filePath);
+
+  if (diff === true || diff === "-") {
+    console.error(diffText);
+  } else if (typeof diff === "string") {
+    await fs.writeFile(diff, diffText, "utf-8");
+  }
+}

package/src/plugins/.beads/.local_version

@@ -0,0 +1 @@
+0.49.2