@aigne/doc-smith 0.9.8-alpha.2 → 0.9.8-alpha.4

package/utils/image-compress.mjs

@@ -1,75 +0,0 @@
-import sharp from "sharp";
-import path from "node:path";
-import { debug } from "./debug.mjs";
-
-/**
- * Compress an image using sharp
- * Supports JPEG, PNG, and WebP formats
- * @param {string} inputPath - Path to the input image file
- * @param {object} options - Compression options
- * @param {number} options.quality - Compression quality (0-100, default: 80)
- * @param {string} options.outputFormat - Output format: 'jpeg', 'png', 'webp' (default: auto-detect from input)
- * @param {string} options.outputPath - Output path for compressed image (if not provided, creates temp file)
- * @returns {Promise<string>} - Path to the compressed image (outputPath if provided, or temp path, or inputPath if compression fails)
- */
-export async function compressImage(inputPath, options = {}) {
-  const { quality = 80, outputFormat, outputPath } = options;
-
-  try {
-    const inputExt = path.extname(inputPath).toLowerCase();
-
-    // Determine output format
-    let format = outputFormat;
-    if (!format) {
-      // Auto-detect from input extension
-      if (inputExt === ".jpg" || inputExt === ".jpeg") {
-        format = "jpeg";
-      } else if (inputExt === ".png") {
-        format = "png";
-      } else if (inputExt === ".webp") {
-        format = "webp";
-      } else {
-        // Default to JPEG for unknown formats
-        format = "jpeg";
-        debug(`Unknown image format ${inputExt}, defaulting to JPEG`);
-      }
-    }
-
-    // Determine output path
-    let finalOutputPath = outputPath;
-    if (!finalOutputPath) {
-      // If no output path provided, create temp file in same directory as input
-      const outputExt = format === "jpeg" ? ".jpg" : format === "png" ? ".png" : ".webp";
-      const inputDir = path.dirname(inputPath);
-      const inputBase = path.basename(inputPath, path.extname(inputPath));
-      finalOutputPath = path.join(inputDir, `${inputBase}.compressed${outputExt}`);
-    }
-
-    // Create sharp instance and compress
-    let sharpInstance = sharp(inputPath);
-
-    // Apply format-specific compression options
-    if (format === "jpeg") {
-      // mozjpeg is a valid sharp option for better JPEG compression
-      const jpegOptions = { quality, mozjpeg: true };
-      sharpInstance = sharpInstance.jpeg(jpegOptions);
-    } else if (format === "png") {
-      sharpInstance = sharpInstance.png({ quality, compressionLevel: 9 });
-    } else if (format === "webp") {
-      sharpInstance = sharpInstance.webp({ quality });
-    }
-
-    // Write compressed image directly to output path
-    await sharpInstance.toFile(finalOutputPath);
-
-    debug(
-      `✅ Image compressed: ${inputPath} -> ${finalOutputPath} (format: ${format}, quality: ${quality})`,
-    );
-
-    return finalOutputPath;
-  } catch (error) {
-    debug(`⚠️  Failed to compress image ${inputPath}: ${error.message}`);
-    // Return original path if compression fails
-    return inputPath;
-  }
-}

package/utils/kroki-utils.mjs

@@ -1,173 +0,0 @@
-import path from "node:path";
-
-import Debug from "debug";
-import fs from "fs-extra";
-import { glob } from "glob";
-import pMap from "p-map";
-import { joinURL } from "ufo";
-
-import {
-  D2_CONFIG,
-  DOC_SMITH_DIR,
-  FILE_CONCURRENCY,
-  KROKI_CONCURRENCY,
-  TMP_ASSETS_DIR,
-  TMP_DIR,
-} from "./constants/index.mjs";
-import { getContentHash } from "./utils.mjs";
-import { d2CodeBlockRegex } from "./d2-utils.mjs";
-
-const debug = Debug("doc-smith");
-
-export async function getChart({ chart = "d2", format = "svg", content, strict }) {
-  const baseUrl = "https://chart.abtnet.io";
-
-  try {
-    const res = await fetch(joinURL(baseUrl, chart, format), {
-      method: "POST",
-      body: content,
-      headers: {
-        Accept: "image/svg+xml",
-        "Content-Type": "text/plain",
-      },
-    });
-    if (strict && !res.ok) {
-      throw new Error(`Could not fetch the chart: ${res.status} ${res.statusText}`);
-    }
-
-    const data = await res.text();
-    return data;
-  } catch (err) {
-    if (strict) throw err;
-
-    console.error(`Could not generate the chart from: ${baseUrl}`, err);
-    return null;
-  }
-}
-
-export async function getD2Svg({ content, strict = false }) {
-  const svgContent = await getChart({
-    chart: "d2",
-    format: "svg",
-    content,
-    strict,
-  });
-  return svgContent;
-}
-
-export async function saveD2Assets({ markdown, docsDir }) {
-  if (!markdown) {
-    return markdown;
-  }
-
-  const { replaced } = await runIterator({
-    input: markdown,
-    regexp: d2CodeBlockRegex,
-    replace: true,
-    fn: async ([_match, _code]) => {
-      const assetDir = path.join(docsDir, "../", TMP_ASSETS_DIR, "d2");
-      await fs.ensureDir(assetDir);
-      const d2Content = [D2_CONFIG, _code].join("\n");
-      const fileName = `${getContentHash(d2Content)}.svg`;
-      const svgPath = path.join(assetDir, fileName);
-
-      if (await fs.pathExists(svgPath)) {
-        debug("Asset cache found, skipping generation", svgPath);
-      } else {
-        try {
-          debug("Generating d2 diagram", svgPath);
-          if (debug.enabled) {
-            const d2FileName = `${getContentHash(d2Content)}.d2`;
-            const d2Path = path.join(assetDir, d2FileName);
-            await fs.writeFile(d2Path, d2Content, { encoding: "utf8" });
-          }
-
-          const svg = await getD2Svg({ content: d2Content });
-          if (svg) {
-            await fs.writeFile(svgPath, svg, { encoding: "utf8" });
-          }
-        } catch (error) {
-          debug("Could not generate the D2 diagram:", error);
-          return _code;
-        }
-      }
-      return `![](${path.posix.join("..", TMP_ASSETS_DIR, "d2", fileName)})`;
-    },
-    options: { concurrency: KROKI_CONCURRENCY },
-  });
-
-  return replaced;
-}
-
-export async function beforePublishHook({ docsDir }) {
-  // Process each markdown file to save the d2 svg assets.
-  const mdFilePaths = await glob("**/*.md", { cwd: docsDir });
-  await pMap(
-    mdFilePaths,
-    async (filePath) => {
-      let finalContent = await fs.readFile(path.join(docsDir, filePath), { encoding: "utf8" });
-      finalContent = await saveD2Assets({ markdown: finalContent, docsDir });
-
-      await fs.writeFile(path.join(docsDir, filePath), finalContent, { encoding: "utf8" });
-    },
-    { concurrency: FILE_CONCURRENCY },
-  );
-}
-
-async function runIterator({ input, regexp, fn = () => {}, options, replace = false }) {
-  if (!input) return input;
-  const matches = [...input.matchAll(regexp)];
-  const results = [];
-  await pMap(
-    matches,
-    async (...args) => {
-      const resultItem = await fn(...args);
-      results.push(resultItem);
-    },
-    options,
-  );
-
-  let replaced = input;
-  if (replace) {
-    let index = 0;
-    replaced = replaced.replace(regexp, () => {
-      return results[index++];
-    });
-  }
-
-  return {
-    results,
-    replaced,
-  };
-}
-
-export async function checkD2Content({ content }) {
-  await ensureTmpDir();
-  const assetDir = path.join(DOC_SMITH_DIR, TMP_DIR, TMP_ASSETS_DIR, "d2");
-  await fs.ensureDir(assetDir);
-  const d2Content = [D2_CONFIG, content].join("\n");
-  const fileName = `${getContentHash(d2Content)}.svg`;
-  const svgPath = path.join(assetDir, fileName);
-
-  if (debug.enabled) {
-    const d2FileName = `${getContentHash(d2Content)}.d2`;
-    const d2Path = path.join(assetDir, d2FileName);
-    await fs.writeFile(d2Path, d2Content, { encoding: "utf8" });
-  }
-
-  if (await fs.pathExists(svgPath)) {
-    debug("Asset cache found, skipping generation", svgPath);
-    return;
-  }
-
-  const svg = await getD2Svg({ content: d2Content, strict: true });
-  await fs.writeFile(svgPath, svg, { encoding: "utf8" });
-}
-
-export async function ensureTmpDir() {
-  const tmpDir = path.join(DOC_SMITH_DIR, TMP_DIR);
-  if (!(await fs.pathExists(path.join(tmpDir, ".gitignore")))) {
-    await fs.ensureDir(tmpDir);
-    await fs.writeFile(path.join(tmpDir, ".gitignore"), "**/*", { encoding: "utf8" });
-  }
-}

package/utils/linter/index.mjs

@@ -1,50 +0,0 @@
-import { LINTER_API_URL } from "../constants/linter.mjs";
-
-export async function lintCode({ code, linter = "biome-lint", suffix = ".js" }) {
-  if (!code) {
-    throw new Error("Code parameter is required");
-  }
-  const timeout = 30 * 1000;
-  let filename = `code${suffix}`;
-  if (suffix === ".dockerfile") {
-    filename = "Dockerfile";
-  }
-  const testData = {
-    filename,
-    content: code,
-    options: {
-      validate_all: true,
-      fix: false,
-      log_level: "INFO",
-      timeout,
-    },
-  };
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-    const response = await fetch(`${LINTER_API_URL}/${linter}/json`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(testData),
-      signal: controller.signal,
-    });
-
-    clearTimeout(timeoutId);
-
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
-
-    const data = await response.json();
-    if (!data) {
-      throw new Error("Invalid response data");
-    }
-
-    return data;
-  } catch (error) {
-    throw new Error(`Linting failed: ${error.message}`);
-  }
-}

package/utils/load-config.mjs

@@ -1,107 +0,0 @@
-import fs from "node:fs/promises";
-import chalk from "chalk";
-import path from "node:path";
-import { parse } from "yaml";
-import { processConfigFields, resolveFileReferences } from "./utils.mjs";
-import { DEFAULT_EXCLUDE_PATTERNS } from "./constants/index.mjs";
-import { findInvalidSourcePaths, toDisplayPath } from "./file-utils.mjs";
-
-export default async function loadConfig({ config, appUrl }) {
-  const configPath = path.isAbsolute(config) ? config : path.join(process.cwd(), config);
-
-  try {
-    // Check if config file exists
-    await fs.access(configPath);
-  } catch (_error) {
-    console.log(`The config file was not found at: ${configPath}`);
-    console.log("You can run 'aigne doc init' to create a new config file.");
-    throw new Error(`The config file was not found at: ${configPath}`);
-  }
-
-  try {
-    // Read and parse YAML file
-    const configContent = await fs.readFile(configPath, "utf-8");
-    let parsedConfig = parse(configContent);
-
-    // Resolve file references (@ prefixed values)
-    parsedConfig = await resolveFileReferences(parsedConfig);
-
-    // Read DOC-SMITH.md if exists in current working directory
-    const docSmithVariants = ["DOC-SMITH.md", "doc-smith.md", "DocSmith.md"];
-    let docSmithContent = "";
-    for (const variant of docSmithVariants) {
-      const docSmithPath = path.join(process.cwd(), variant);
-      try {
-        const content = await fs.readFile(docSmithPath, "utf-8");
-        if (content && content.trim()) {
-          docSmithContent = content.trim();
-          console.log(`✓ Found ${chalk.cyan(variant)}, custom rules loaded`);
-          break; // Use the first found file
-        }
-      } catch (error) {
-        if (error.code !== "ENOENT") {
-          // File exists but can't be read (permission issue, etc.)
-          console.warn(`⚠️  Found ${variant} but failed to read: ${error.message}`);
-        }
-        // ENOENT means file doesn't exist, continue to next variant
-      }
-    }
-
-    // Append DOC-SMITH content to rules if found
-    if (docSmithContent) {
-      const existingRules = parsedConfig.rules || "";
-      parsedConfig.rules = existingRules
-        ? `${existingRules}\n\n${docSmithContent}`
-        : docSmithContent;
-    }
-
-    if (appUrl) {
-      parsedConfig.appUrl = appUrl.includes("://") ? appUrl : `https://${appUrl}`;
-    }
-
-    // Parse new configuration fields and convert keys to actual content
-    const processedConfig = await processConfigFields(parsedConfig);
-
-    // Validate sourcePaths against exclude patterns
-    const sourcesPath = processedConfig.sourcesPath || parsedConfig.sourcesPath;
-    if (sourcesPath) {
-      const excludePatterns = [
-        ...DEFAULT_EXCLUDE_PATTERNS,
-        ...(processedConfig.excludePatterns || parsedConfig.excludePatterns || []),
-      ];
-
-      const { excluded, notFound } = await findInvalidSourcePaths(sourcesPath, excludePatterns);
-
-      if (excluded.length > 0 || notFound.length > 0) {
-        const warnings = [];
-
-        if (excluded.length > 0) {
-          warnings.push(
-            `⚠️  These paths were excluded (ignored by config):\n${excluded.map((p) => `  - ${chalk.yellow(p)}`).join("\n")}`,
-          );
-        }
-
-        if (notFound.length > 0) {
-          warnings.push(
-            `🚫 These paths were skipped because they do not exist:\n${notFound.map((p) => `  - ${chalk.red(p)}`).join("\n")}`,
-          );
-        }
-
-        warnings.push(
-          `💡 Tip: You can remove these paths in ${chalk.cyan(toDisplayPath(configPath))}`,
-        );
-
-        console.warn(`${warnings.join("\n\n")}\n`);
-      }
-    }
-
-    return {
-      lastGitHead: parsedConfig.lastGitHead || "",
-      ...parsedConfig,
-      ...processedConfig,
-    };
-  } catch (error) {
-    console.error(`I encountered an error while parsing the config file: ${error.message}`);
-    throw new Error(`I could not parse the config file: ${error.message}`);
-  }
-}

package/utils/markdown/index.mjs

@@ -1,26 +0,0 @@
-import remarkGfm from "remark-gfm";
-import remarkParse from "remark-parse";
-import { unified } from "unified";
-import { visit } from "unist-util-visit";
-import { VFile } from "vfile";
-
-export function traverseMarkdownAst({ ast, test, visitor }) {
-  if (!ast || !test || !visitor) {
-    throw new Error("Required parameters missing: ast, test, and visitor must be provided");
-  }
-  visit(ast, test, visitor);
-}
-
-export function getMarkdownAst({ markdown }) {
-  if (!markdown || typeof markdown !== "string") {
-    throw new Error("Invalid markdown input: must be a non-empty string");
-  }
-  const file = new VFile({ value: markdown });
-  const processor = unified().use(remarkParse).use(remarkGfm);
-  try {
-    const ast = processor.parse(file);
-    return ast;
-  } catch (error) {
-    throw new Error(`Failed to parse markdown: ${error.message}`);
-  }
-}