@s-hirano-ist/s-scripts 4.2.0 → 4.3.0

package/dist/chunk-MJYGMGH5.js

@@ -0,0 +1,382 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+import {
+  RAG_CONFIG,
+  deletePointsByChunkIds,
+  ensureCollection,
+  getCollectionStats,
+  getExistingHashes,
+  listAllChunkIds,
+  upsertPoints
+} from "./chunk-J4VLH4VA.js";
+import {
+  parseMarkdownFrontmatter
+} from "./chunk-HDYQV2Y2.js";
+import {
+  globPaths
+} from "./chunk-AJMTRCPJ.js";
+import {
+  reportCliError
+} from "./chunk-4CXH2QIX.js";
+import "./chunk-JZOR5GA2.js";
+
+// ../search/dist/chunker.js
+import { createHash } from "node:crypto";
+function generateHash(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function generateChunkId(docId, index) {
+  return `${docId}#${index}`;
+}
+function parseJsonArticle(filePath, content) {
+  const json = JSON.parse(content);
+  const docId = `file:${filePath}`;
+  const chunks = [];
+  for (let i = 0; i < json.body.length; i++) {
+    const item = json.body[i];
+    const textParts = [];
+    if (item.title)
+      textParts.push(item.title);
+    if (item.ogTitle && item.ogTitle !== item.title)
+      textParts.push(item.ogTitle);
+    if (item.ogDescription)
+      textParts.push(item.ogDescription);
+    if (item.quote)
+      textParts.push(item.quote);
+    const text = textParts.join("\n");
+    if (!text.trim())
+      continue;
+    const chunkId = generateChunkId(docId, i);
+    chunks.push({
+      type: "bookmark_json",
+      content_type: "articles",
+      top_heading: json.heading,
+      doc_id: docId,
+      chunk_id: chunkId,
+      title: item.title || item.ogTitle || "Untitled",
+      url: item.url,
+      heading_path: [json.heading],
+      text,
+      content_hash: generateHash(text)
+    });
+  }
+  return chunks;
+}
+function parseFrontmatter(content) {
+  const parsed = parseMarkdownFrontmatter(content);
+  const frontmatter = {
+    heading: typeof parsed.data.heading === "string" ? parsed.data.heading : "unknown"
+  };
+  if (typeof parsed.data.description === "string") {
+    frontmatter.description = parsed.data.description;
+  }
+  if (typeof parsed.data.draft === "boolean") {
+    frontmatter.draft = parsed.data.draft;
+  }
+  return { frontmatter, body: parsed.content };
+}
+function pushPreambleSection(state) {
+  if (state.preambleContent.trim()) {
+    state.sections.push({
+      headingPath: [],
+      title: "",
+      content: state.preambleContent,
+      level: 0
+    });
+  }
+}
+function handleHeadingLine(state, headingMatch) {
+  if (!state.preambleDone) {
+    state.preambleDone = true;
+    pushPreambleSection(state);
+  }
+  if (state.currentSection?.content.trim()) {
+    state.sections.push(state.currentSection);
+  }
+  const level = headingMatch[1].length;
+  const title = headingMatch[2];
+  const headingStack = state.headingStack;
+  let top = headingStack.at(-1);
+  while (top && top.level >= level) {
+    headingStack.pop();
+    top = headingStack.at(-1);
+  }
+  headingStack.push({ level, title });
+  state.currentSection = {
+    headingPath: headingStack.map((h) => h.title),
+    title,
+    content: "",
+    level
+  };
+}
+function splitMarkdownByHeadings(content) {
+  const state = {
+    sections: [],
+    currentSection: null,
+    headingStack: [],
+    // Preamble buffer (content before first H2/H3)
+    preambleContent: "",
+    preambleDone: false
+  };
+  for (const line of content.split("\n")) {
+    if (/^#\s+\S/u.test(line)) {
+      continue;
+    }
+    const headingMatch = /^(#{2,3})\s+(\S.*)$/u.exec(line);
+    if (headingMatch) {
+      handleHeadingLine(state, headingMatch);
+    } else if (!state.preambleDone) {
+      state.preambleContent += `${line}
+`;
+    } else if (state.currentSection) {
+      state.currentSection.content += `${line}
+`;
+    }
+  }
+  if (!state.preambleDone) {
+    pushPreambleSection(state);
+  }
+  if (state.currentSection?.content.trim()) {
+    state.sections.push(state.currentSection);
+  }
+  return state.sections;
+}
+function splitByParagraphs(text, maxLength) {
+  if (text.length <= maxLength) {
+    return [text];
+  }
+  const paragraphs = text.split(/\n{2,}/u);
+  const chunks = [];
+  let currentChunk = "";
+  for (const para of paragraphs) {
+    if (currentChunk.length + para.length > maxLength && currentChunk) {
+      chunks.push(currentChunk.trim());
+      currentChunk = para;
+    } else {
+      currentChunk += (currentChunk ? "\n\n" : "") + para;
+    }
+  }
+  if (currentChunk.trim()) {
+    chunks.push(currentChunk.trim());
+  }
+  return chunks;
+}
+function parseMarkdownWithDocId(docId, content, contentType = "notes") {
+  const { frontmatter, body } = parseFrontmatter(content);
+  const chunks = [];
+  if (frontmatter.draft) {
+    return [];
+  }
+  const sections = splitMarkdownByHeadings(body);
+  let chunkIndex = 0;
+  for (const section of sections) {
+    const textChunks = splitByParagraphs(section.content, RAG_CONFIG.chunking.maxChunkLength);
+    for (const text of textChunks) {
+      if (!text.trim())
+        continue;
+      const isPreamble = section.level === 0 && section.title === "";
+      const sectionTitle = isPreamble ? frontmatter.description ?? frontmatter.heading : section.title;
+      const fullHeadingPath = isPreamble ? [frontmatter.heading] : [frontmatter.heading, ...section.headingPath];
+      const chunkId = generateChunkId(docId, chunkIndex);
+      chunks.push({
+        type: "markdown_note",
+        content_type: contentType,
+        top_heading: frontmatter.heading,
+        doc_id: docId,
+        chunk_id: chunkId,
+        title: sectionTitle,
+        heading_path: fullHeadingPath,
+        text,
+        content_hash: generateHash(text)
+      });
+      chunkIndex++;
+    }
+  }
+  return chunks;
+}
+function parseMarkdown(filePath, content, contentType = "notes") {
+  return parseMarkdownWithDocId(`file:${filePath}`, content, contentType);
+}
+
+// ../search/dist/ingest.js
+import { setTimeout } from "node:timers/promises";
+var BATCH_SIZE = 20;
+var MAX_RETRIES = 3;
+var RETRY_DELAY_MS = 2e3;
+async function withRetry(fn, retries = MAX_RETRIES) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (i === retries - 1)
+        throw error;
+      console.log(`  Retry ${i + 1}/${retries} after error...`);
+      await setTimeout(RETRY_DELAY_MS);
+    }
+  }
+  throw new Error("Unreachable");
+}
+async function ingestChunks(chunks, options) {
+  console.log(`Total chunks: ${chunks.length}
+`);
+  let changedChunks;
+  let skippedChunks;
+  if (options.force) {
+    changedChunks = chunks;
+    skippedChunks = 0;
+  } else {
+    console.log("Checking for changes...");
+    const chunkIds = chunks.map((c) => c.chunk_id);
+    const existingHashes = await getExistingHashes(chunkIds);
+    changedChunks = chunks.filter((chunk) => {
+      const existingHash = existingHashes.get(chunk.chunk_id);
+      return existingHash !== chunk.content_hash;
+    });
+    skippedChunks = chunks.length - changedChunks.length;
+  }
+  console.log(`Changed chunks: ${changedChunks.length}`);
+  console.log(`Skipped (unchanged): ${skippedChunks}
+`);
+  if (changedChunks.length === 0) {
+    console.log("No changes detected. Done!");
+    return {
+      totalChunks: chunks.length,
+      changedChunks: 0,
+      skippedChunks
+    };
+  }
+  console.log("Upserting to Qdrant...");
+  let processed = 0;
+  for (let i = 0; i < changedChunks.length; i += BATCH_SIZE) {
+    const batch = changedChunks.slice(i, i + BATCH_SIZE);
+    const points = batch.map((chunk) => ({
+      id: chunk.chunk_id,
+      text: chunk.text,
+      payload: chunk
+    }));
+    await withRetry(() => upsertPoints(points));
+    processed += batch.length;
+    console.log(`  Progress: ${processed}/${changedChunks.length}`);
+    await setTimeout(100);
+  }
+  return {
+    totalChunks: chunks.length,
+    changedChunks: changedChunks.length,
+    skippedChunks
+  };
+}
+async function pruneOrphans(currentChunkIds) {
+  const existingIds = await listAllChunkIds();
+  const currentSet = new Set(currentChunkIds);
+  const orphanIds = existingIds.filter((id) => !currentSet.has(id));
+  console.log(`Existing Qdrant chunks: ${existingIds.length}`);
+  console.log(`Orphan chunks to delete: ${orphanIds.length}`);
+  if (orphanIds.length === 0) {
+    return { deletedCount: 0 };
+  }
+  let deleted = 0;
+  for (let i = 0; i < orphanIds.length; i += BATCH_SIZE) {
+    const batch = orphanIds.slice(i, i + BATCH_SIZE);
+    await withRetry(() => deletePointsByChunkIds(batch));
+    deleted += batch.length;
+    console.log(`  Prune progress: ${deleted}/${orphanIds.length}`);
+    await setTimeout(100);
+  }
+  return { deletedCount: deleted };
+}
+
+// src/rag/ingest-command.ts
+import { readFileSync } from "node:fs";
+
+// src/rag/ingest-config.ts
+var INGEST_CONFIG = {
+  paths: {
+    notes: "markdown/note/**/*.md",
+    books: "markdown/book/**/*.md",
+    articles: "json/article/**/*.json"
+  }
+};
+
+// src/rag/ingest-command.ts
+async function listFiles() {
+  const files = [];
+  const articleFiles = await globPaths(INGEST_CONFIG.paths.articles);
+  for (const path of articleFiles) {
+    files.push({ path, type: "json", contentType: "articles" });
+  }
+  const noteFiles = await globPaths(INGEST_CONFIG.paths.notes);
+  for (const path of noteFiles) {
+    files.push({ path, type: "markdown", contentType: "notes" });
+  }
+  const bookFiles = await globPaths(INGEST_CONFIG.paths.books);
+  for (const path of bookFiles) {
+    files.push({ path, type: "markdown", contentType: "books" });
+  }
+  return files;
+}
+function parseFile(file) {
+  const content = readFileSync(file.path, "utf-8");
+  if (file.type === "json") {
+    return parseJsonArticle(file.path, content);
+  }
+  return parseMarkdown(file.path, content, file.contentType);
+}
+async function ingest(flags) {
+  console.log("Starting ingest...\n");
+  if (flags.dryRun) {
+    console.log("Dry-run mode: no writes to Qdrant\n");
+  } else {
+    await ensureCollection();
+    const initialStats = await getCollectionStats();
+    console.log(`Initial points count: ${initialStats.pointsCount}
+`);
+  }
+  if (flags.force) {
+    console.log("Force mode enabled: skipping change detection\n");
+  }
+  const files = await listFiles();
+  const articleCount = files.filter((f) => f.contentType === "articles").length;
+  const noteCount = files.filter((f) => f.contentType === "notes").length;
+  const bookCount = files.filter((f) => f.contentType === "books").length;
+  console.log(`Found ${files.length} files to process`);
+  console.log(`  - Articles: ${articleCount}`);
+  console.log(`  - Notes: ${noteCount}`);
+  console.log(`  - Books: ${bookCount}
+`);
+  console.log("Parsing files...");
+  const allChunks = [];
+  for (const file of files) {
+    try {
+      const chunks = parseFile(file);
+      allChunks.push(...chunks);
+    } catch (error) {
+      reportCliError(error, "rag-ingest");
+      console.error(`Error parsing ${file.path}:`, error);
+    }
+  }
+  console.log(`Total chunks parsed: ${allChunks.length}`);
+  if (flags.dryRun) {
+    console.log("Dry-run complete. Skipping upsert and prune.");
+    return;
+  }
+  const result = await ingestChunks(allChunks, { force: flags.force });
+  const pruneResult = await pruneOrphans(allChunks.map((c) => c.chunk_id));
+  const finalStats = await getCollectionStats();
+  console.log(`
+Final points count: ${finalStats.pointsCount}`);
+  console.log(
+    `Ingest completed! (${result.changedChunks} changed, ${result.skippedChunks} skipped, ${pruneResult.deletedCount} pruned)`
+  );
+}
+async function main() {
+  if (!process.env.QDRANT_URL) {
+    throw new Error("QDRANT_URL environment variable is required.");
+  }
+  const flags = {
+    force: process.argv.includes("--force"),
+    dryRun: process.argv.includes("--dry-run")
+  };
+  await ingest(flags);
+}
+export {
+  main
+};

package/dist/{chunk-M6LFKOUH.js → chunk-MVYAZJB2.js}

@@ -57,13 +57,13 @@ function createObjectStorageClient(config = loadStorageConfig()) {
     async getObject(bucket, key) {
       const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
       if (!(result.Body instanceof Readable))
-        throw new Error("Object storage returned no Node readable body");
+        throw new TypeError("Object storage returned no Node readable body");
       return result.Body;
     },
     async downloadObject(bucket, key, destination) {
       const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
       if (!(result.Body instanceof Readable))
-        throw new Error("Object storage returned no Node readable body");
+        throw new TypeError("Object storage returned no Node readable body");
       await pipeline(result.Body, createWriteStream(destination));
     },
     async statObject(bucket, key) {

package/dist/chunk-SFKQ2RAP.js

@@ -0,0 +1,87 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+import {
+  ensureCollection,
+  search
+} from "./chunk-J4VLH4VA.js";
+import "./chunk-JZOR5GA2.js";
+
+// src/rag/search-command.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {};
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--top-k" && i + 1 < args.length) {
+      options.topK = Number(args[++i]);
+    } else if (arg === "--type" && i + 1 < args.length) {
+      options.type = args[++i];
+    } else if (arg === "--heading" && i + 1 < args.length) {
+      options.heading = args[++i];
+    } else if (arg === "--content-type" && i + 1 < args.length) {
+      const value = args[++i];
+      const types = value.split(",");
+      options.contentType = types.length === 1 ? types[0] : types;
+    } else {
+      positional.push(arg);
+    }
+  }
+  const query = positional.join(" ");
+  if (!query) {
+    console.error(
+      "Usage: rag-search <query> [--top-k N] [--type markdown_note|bookmark_json] [--heading HEADING] [--content-type articles|books|notes]"
+    );
+    process.exitCode = 1;
+    return void 0;
+  }
+  return { query, options };
+}
+async function searchContent(query, options = {}) {
+  const results = await search(query, {
+    topK: options.topK,
+    filter: {
+      type: options.type,
+      top_heading: options.heading,
+      content_type: options.contentType
+    }
+  });
+  return { results, query, totalResults: results.length };
+}
+async function search2() {
+  const args = parseArgs();
+  if (!args) return;
+  const { query, options } = args;
+  console.log(`Searching for: "${query}"`);
+  if (options.topK) console.log(`  top-k: ${options.topK}`);
+  if (options.type) console.log(`  type: ${options.type}`);
+  if (options.heading) console.log(`  heading: ${options.heading}`);
+  if (options.contentType)
+    console.log(
+      `  content-type: ${Array.isArray(options.contentType) ? options.contentType.join(",") : options.contentType}`
+    );
+  console.log();
+  await ensureCollection();
+  const response = await searchContent(query, options);
+  console.log(`Found ${response.totalResults} results:
+`);
+  for (const [i, result] of response.results.entries()) {
+    console.log(`--- Result ${i + 1} (score: ${result.score.toFixed(4)}) ---`);
+    console.log(`Title: ${result.title}`);
+    if (result.url) console.log(`URL: ${result.url}`);
+    console.log(`Type: ${result.type}`);
+    console.log(`Content-Type: ${result.content_type}`);
+    console.log(`Heading: ${result.heading_path.join(" > ")}`);
+    console.log(`
+${result.text}
+`);
+  }
+}
+async function main() {
+  if (!process.env.QDRANT_URL) {
+    throw new Error("QDRANT_URL environment variable is required.");
+  }
+  await search2();
+}
+export {
+  main
+};

package/dist/cleanup-minio-images.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
-import {
-  createObjectStorageClient
-} from "./chunk-M6LFKOUH.js";
-import {
-  createPushoverService
-} from "./chunk-7PVU2Z32.js";
 import {
   globPaths
 } from "./chunk-AJMTRCPJ.js";
+import {
+  createObjectStorageClient
+} from "./chunk-MVYAZJB2.js";
+import {
+  cliNotifications,
+  reportCliError,
+  runCli
+} from "./chunk-4CXH2QIX.js";
 import "./chunk-JZOR5GA2.js";
 
 // src/cleanup-minio-images.ts
@@ -26,93 +28,72 @@ function listObjects(client, bucket, prefix) {
 async function main() {
   const dryRun = process.argv.includes("--dry-run");
   const env = {
-    PUSHOVER_URL: process.env.PUSHOVER_URL,
-    PUSHOVER_USER_KEY: process.env.PUSHOVER_USER_KEY,
-    PUSHOVER_APP_TOKEN: process.env.PUSHOVER_APP_TOKEN,
     S3_BUCKET_NAME: process.env.S3_BUCKET_NAME
   };
   if (Object.values(env).some((v) => !v)) {
     throw new Error("Required environment variables are not set.");
   }
   const contentsPath = process.env.S_CONTENTS_PATH ?? process.cwd();
-  const notificationService = createPushoverService({
-    url: env.PUSHOVER_URL ?? "",
-    userKey: env.PUSHOVER_USER_KEY ?? "",
-    appToken: env.PUSHOVER_APP_TOKEN ?? ""
-  });
+  const notificationService = cliNotifications;
   const storageClient = createObjectStorageClient();
   const bucketName = env.S3_BUCKET_NAME ?? "";
-  try {
-    const localFiles = await globPaths(`${contentsPath}/image/dump/*`);
-    const localFileNames = new Set(
-      localFiles.filter((f) => isImageFile(f)).map((f) => basename(f))
-    );
-    console.log(
-      `\u{1F4C1} \u30ED\u30FC\u30AB\u30EB\u306B ${localFileNames.size} \u4EF6\u306E\u753B\u50CF\u30D5\u30A1\u30A4\u30EB\u3092\u691C\u51FA\u3057\u307E\u3057\u305F\u3002`
-    );
-    const [originalKeys, thumbnailKeys] = await Promise.all([
-      listObjects(storageClient, bucketName, `${ORIGINAL_IMAGE_PATH}/`),
-      listObjects(storageClient, bucketName, `${THUMBNAIL_IMAGE_PATH}/`)
-    ]);
-    console.log(
-      `\u{1F4E6} S3: original ${originalKeys.length} \u4EF6, thumbnail ${thumbnailKeys.length} \u4EF6`
-    );
-    const orphanedOriginals = originalKeys.filter(
-      (key) => !localFileNames.has(basename(key))
-    );
-    const orphanedThumbnails = thumbnailKeys.filter(
-      (key) => !localFileNames.has(basename(key))
-    );
-    const totalOrphaned = orphanedOriginals.length + orphanedThumbnails.length;
-    if (totalOrphaned === 0) {
-      console.log("\u2705 \u5B64\u7ACB\u30D5\u30A1\u30A4\u30EB\u306A\u3057");
-      if (!dryRun)
-        await notificationService.notifyInfo(
-          `${SCRIPT_NAME} completed: no orphaned files`,
-          { caller: SCRIPT_NAME }
-        );
-      return;
-    }
-    console.log(
-      `\u{1F5D1}\uFE0F  \u5B64\u7ACB\u30D5\u30A1\u30A4\u30EB\u691C\u51FA: original ${orphanedOriginals.length} \u4EF6, thumbnail ${orphanedThumbnails.length} \u4EF6`
-    );
-    let deletedCount = 0;
-    let errorCount = 0;
-    for (const key of [...orphanedOriginals, ...orphanedThumbnails]) {
-      try {
-        if (dryRun) {
-          console.log(`\u{1F50D} [dry-run] \u524A\u9664\u4E88\u5B9A: ${key}`);
-        } else {
-          await storageClient.removeObject(bucketName, key);
-          console.log(`\u{1F5D1}\uFE0F  \u524A\u9664: ${key}`);
-        }
-        deletedCount++;
-      } catch (error) {
-        console.error(`\u274C \u524A\u9664\u30A8\u30E9\u30FC\uFF08${key}\uFF09:`, error);
-        errorCount++;
-      }
-    }
-    console.log(
-      `
-\u{1F4CA} \u7D50\u679C: \u524A\u9664 ${deletedCount} \u4EF6, \u30A8\u30E9\u30FC ${errorCount} \u4EF6${dryRun ? " (dry-run)" : ""}`
-    );
+  const localFiles = await globPaths(`${contentsPath}/image/dump/*`);
+  const localFileNames = new Set(
+    localFiles.filter((f) => isImageFile(f)).map((f) => basename(f))
+  );
+  console.log(
+    `\u{1F4C1} \u30ED\u30FC\u30AB\u30EB\u306B ${localFileNames.size} \u4EF6\u306E\u753B\u50CF\u30D5\u30A1\u30A4\u30EB\u3092\u691C\u51FA\u3057\u307E\u3057\u305F\u3002`
+  );
+  const [originalKeys, thumbnailKeys] = await Promise.all([
+    listObjects(storageClient, bucketName, `${ORIGINAL_IMAGE_PATH}/`),
+    listObjects(storageClient, bucketName, `${THUMBNAIL_IMAGE_PATH}/`)
+  ]);
+  console.log(
+    `\u{1F4E6} S3: original ${originalKeys.length} \u4EF6, thumbnail ${thumbnailKeys.length} \u4EF6`
+  );
+  const orphanedOriginals = originalKeys.filter(
+    (key) => !localFileNames.has(basename(key))
+  );
+  const orphanedThumbnails = thumbnailKeys.filter(
+    (key) => !localFileNames.has(basename(key))
+  );
+  const totalOrphaned = orphanedOriginals.length + orphanedThumbnails.length;
+  if (totalOrphaned === 0) {
+    console.log("\u2705 \u5B64\u7ACB\u30D5\u30A1\u30A4\u30EB\u306A\u3057");
     if (!dryRun)
-      await notificationService.notifyInfo(`${SCRIPT_NAME} completed`, {
-        caller: SCRIPT_NAME
-      });
-  } catch (error) {
-    console.error("\u274C \u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F:", error);
-    if (!dryRun)
-      await notificationService.notifyError(
-        `${SCRIPT_NAME} failed: ${String(error)}`,
-        {
-          caller: SCRIPT_NAME
-        }
+      await notificationService.notifyInfo(
+        `${SCRIPT_NAME} completed: no orphaned files`,
+        { caller: SCRIPT_NAME }
       );
-    process.exit(1);
+    return;
   }
+  console.log(
+    `\u{1F5D1}\uFE0F  \u5B64\u7ACB\u30D5\u30A1\u30A4\u30EB\u691C\u51FA: original ${orphanedOriginals.length} \u4EF6, thumbnail ${orphanedThumbnails.length} \u4EF6`
+  );
+  let deletedCount = 0;
+  let errorCount = 0;
+  for (const key of [...orphanedOriginals, ...orphanedThumbnails]) {
+    try {
+      if (dryRun) {
+        console.log(`\u{1F50D} [dry-run] \u524A\u9664\u4E88\u5B9A: ${key}`);
+      } else {
+        await storageClient.removeObject(bucketName, key);
+        console.log(`\u{1F5D1}\uFE0F  \u524A\u9664: ${key}`);
+      }
+      deletedCount++;
+    } catch (error) {
+      reportCliError(error, "cleanup-minio-images");
+      console.error(`\u274C \u524A\u9664\u30A8\u30E9\u30FC\uFF08${key}\uFF09:`, error);
+      errorCount++;
+    }
+  }
+  console.log(
+    `
+\u{1F4CA} \u7D50\u679C: \u524A\u9664 ${deletedCount} \u4EF6, \u30A8\u30E9\u30FC ${errorCount} \u4EF6${dryRun ? " (dry-run)" : ""}`
+  );
+  if (!dryRun)
+    await notificationService.notifyInfo(`${SCRIPT_NAME} completed`, {
+      caller: SCRIPT_NAME
+    });
 }
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+await runCli("cleanup-minio-images", main);

package/dist/enrich-books.js

@@ -6,6 +6,10 @@ import {
 import {
   globPaths
 } from "./chunk-AJMTRCPJ.js";
+import {
+  reportCliError,
+  runCli
+} from "./chunk-4CXH2QIX.js";
 import "./chunk-JZOR5GA2.js";
 
 // src/enrich-books.ts
@@ -85,6 +89,7 @@ ${body}`;
       }
       enrichedCount++;
     } catch (error) {
+      reportCliError(error, "enrich-books");
       console.error(`\u274C ${fileName}:`, error);
       errorCount++;
     }
@@ -94,7 +99,4 @@ ${body}`;
 \u{1F4CA} \u7D50\u679C: \u66F4\u65B0 ${enrichedCount} \u4EF6, \u30A8\u30E9\u30FC ${errorCount} \u4EF6${dryRun ? " (dry-run)" : ""}`
   );
 }
-main().catch((error) => {
-  console.error("\u274C \u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F:", error);
-  process.exit(1);
-});
+await runCli("enrich-books", main);