@s-hirano-ist/s-scripts 1.26.8 → 4.0.0

package/dist/chunk-J4VLH4VA.js

@@ -0,0 +1,267 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+
+// ../search/dist/qdrant-client.js
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+// ../search/dist/config.js
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value)
+    throw new Error(`${name} environment variable is required`);
+  return value;
+}
+function envWithDefault(name, defaultValue) {
+  return process.env[name] || defaultValue;
+}
+var RAG_CONFIG = {
+  qdrant: {
+    collectionName: requireEnv("QDRANT_COLLECTION_NAME"),
+    vectorSize: Number(envWithDefault("EMBEDDING_VECTOR_SIZE", "384")),
+    distance: "Cosine"
+  },
+  embedding: {
+    // Deployed services and ingestion jobs always use Qdrant Cloud Inference.
+    // Keep TEI only for explicitly enabled, non-production local development.
+    url: process.env.LOCAL_DEV_MODE === "true" && process.env.VERCEL !== "1" && process.env.NODE_ENV !== "production" ? process.env.EMBEDDING_URL : void 0,
+    model: envWithDefault("EMBEDDING_MODEL", "intfloat/multilingual-e5-small")
+  },
+  chunking: { maxChunkLength: 2e3, headingLevels: [2, 3] }
+};
+
+// ../search/dist/qdrant-client.js
+var client = null;
+async function embedLocally(texts) {
+  const { url } = RAG_CONFIG.embedding;
+  if (!url)
+    throw new Error("EMBEDDING_URL environment variable is required");
+  const response = await fetch(`${url.replace(/\/$/u, "")}/embed`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ inputs: texts, normalize: true, truncate: true })
+  });
+  if (!response.ok) {
+    throw new Error(`Embedding request failed (${response.status}): ${await response.text()}`);
+  }
+  const embeddings = await response.json();
+  if (!Array.isArray(embeddings) || embeddings.length !== texts.length || embeddings.some((embedding) => !Array.isArray(embedding) || embedding.some((value) => typeof value !== "number"))) {
+    throw new TypeError("Embedding API returned an invalid response");
+  }
+  return embeddings;
+}
+function getQdrantClient(config) {
+  if (!client) {
+    const url = config?.url ?? process.env.QDRANT_URL;
+    const apiKey = config?.apiKey ?? process.env.QDRANT_API_KEY;
+    if (!url) {
+      throw new Error("QDRANT_URL environment variable is required");
+    }
+    client = new QdrantClient({
+      url,
+      apiKey
+    });
+  }
+  return client;
+}
+async function deleteCollection(collectionName) {
+  const qdrant = getQdrantClient();
+  await qdrant.deleteCollection(collectionName);
+}
+async function ensureCollection() {
+  const qdrant = getQdrantClient();
+  const { collectionName, vectorSize, distance } = RAG_CONFIG.qdrant;
+  const collections = await qdrant.getCollections();
+  const exists = collections.collections.some((c) => c.name === collectionName);
+  if (exists) {
+    console.log(`Collection ${collectionName} already exists.`);
+  } else {
+    console.log(`Creating collection: ${collectionName}`);
+    await qdrant.createCollection(collectionName, {
+      vectors: {
+        size: vectorSize,
+        distance
+      }
+    });
+    console.log(`Collection ${collectionName} created successfully.`);
+  }
+  await qdrant.createPayloadIndex(collectionName, {
+    field_name: "type",
+    field_schema: "keyword",
+    wait: true
+  });
+  await qdrant.createPayloadIndex(collectionName, {
+    field_name: "top_heading",
+    field_schema: "keyword",
+    wait: true
+  });
+  await qdrant.createPayloadIndex(collectionName, {
+    field_name: "content_type",
+    field_schema: "keyword",
+    wait: true
+  });
+  console.log("Payload indexes ensured for: type, top_heading, content_type");
+}
+async function upsertPoints(points) {
+  const qdrant = getQdrantClient();
+  const { collectionName } = RAG_CONFIG.qdrant;
+  const localEmbeddings = RAG_CONFIG.embedding.url ? await embedLocally(points.map((point) => point.text)) : void 0;
+  const qdrantPoints = points.map((p, index) => ({
+    id: hashToUint(p.id),
+    vector: localEmbeddings?.[index] ?? {
+      text: p.text,
+      model: RAG_CONFIG.embedding.model
+    },
+    payload: p.payload
+  }));
+  await qdrant.upsert(collectionName, {
+    wait: true,
+    points: qdrantPoints
+  });
+}
+async function getExistingHashes(chunkIds) {
+  const qdrant = getQdrantClient();
+  const { collectionName } = RAG_CONFIG.qdrant;
+  const hashMap = /* @__PURE__ */ new Map();
+  if (chunkIds.length === 0)
+    return hashMap;
+  const numericIds = chunkIds.map((id) => hashToUint(id));
+  try {
+    const result = await qdrant.retrieve(collectionName, {
+      ids: numericIds,
+      with_payload: ["chunk_id", "content_hash"]
+    });
+    for (const point of result) {
+      const payload = point.payload;
+      if (payload?.chunk_id && payload?.content_hash) {
+        hashMap.set(payload.chunk_id, payload.content_hash);
+      }
+    }
+  } catch {
+  }
+  return hashMap;
+}
+async function search(queryText, options = {}) {
+  const qdrant = getQdrantClient();
+  const { collectionName } = RAG_CONFIG.qdrant;
+  const { topK = 10, filter } = options;
+  const filterConditions = [];
+  if (filter?.type) {
+    filterConditions.push({
+      key: "type",
+      match: { value: filter.type }
+    });
+  }
+  if (filter?.top_heading) {
+    filterConditions.push({
+      key: "top_heading",
+      match: { value: filter.top_heading }
+    });
+  }
+  if (filter?.content_type) {
+    if (Array.isArray(filter.content_type)) {
+      filterConditions.push({
+        key: "content_type",
+        match: { any: filter.content_type }
+      });
+    } else {
+      filterConditions.push({
+        key: "content_type",
+        match: { value: filter.content_type }
+      });
+    }
+  }
+  const query = RAG_CONFIG.embedding.url ? (await embedLocally([queryText]))[0] : { text: queryText, model: RAG_CONFIG.embedding.model };
+  const result = await qdrant.query(collectionName, {
+    query,
+    limit: topK,
+    with_payload: true,
+    filter: filterConditions.length > 0 ? { must: filterConditions } : void 0
+  });
+  return result.points.map((r) => {
+    const payload = r.payload;
+    return {
+      score: r.score,
+      text: payload.text,
+      title: payload.title,
+      url: payload.url,
+      heading_path: payload.heading_path,
+      type: payload.type,
+      content_type: payload.content_type,
+      doc_id: payload.doc_id
+    };
+  });
+}
+async function listAllChunkIds() {
+  const qdrant = getQdrantClient();
+  const { collectionName } = RAG_CONFIG.qdrant;
+  const chunkIds = [];
+  const pageSize = 256;
+  let nextOffset;
+  try {
+    do {
+      const result = await qdrant.scroll(collectionName, {
+        limit: pageSize,
+        offset: typeof nextOffset === "string" || typeof nextOffset === "number" ? nextOffset : void 0,
+        with_payload: ["chunk_id"],
+        with_vector: false
+      });
+      for (const point of result.points) {
+        const payload = point.payload;
+        if (payload?.chunk_id) {
+          chunkIds.push(payload.chunk_id);
+        }
+      }
+      nextOffset = result.next_page_offset;
+    } while (nextOffset !== null && nextOffset !== void 0);
+  } catch {
+  }
+  return chunkIds;
+}
+async function deletePointsByChunkIds(chunkIds) {
+  if (chunkIds.length === 0)
+    return;
+  const qdrant = getQdrantClient();
+  const { collectionName } = RAG_CONFIG.qdrant;
+  const numericIds = chunkIds.map((id) => hashToUint(id));
+  await qdrant.delete(collectionName, {
+    wait: true,
+    points: numericIds
+  });
+}
+async function getCollectionStats() {
+  const qdrant = getQdrantClient();
+  const { collectionName } = RAG_CONFIG.qdrant;
+  try {
+    const info = await qdrant.getCollection(collectionName);
+    return {
+      pointsCount: info.points_count ?? 0,
+      status: info.status
+    };
+  } catch {
+    return {
+      pointsCount: 0,
+      status: "not_found"
+    };
+  }
+}
+function hashToUint(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.codePointAt(i) ?? 0;
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+
+export {
+  RAG_CONFIG,
+  getQdrantClient,
+  deleteCollection,
+  ensureCollection,
+  upsertPoints,
+  getExistingHashes,
+  search,
+  listAllChunkIds,
+  deletePointsByChunkIds,
+  getCollectionStats
+};

package/dist/chunk-JZOR5GA2.js

@@ -0,0 +1,42 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-KKZP7ZF3.js

@@ -0,0 +1,77 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+
+// ../image-processing/dist/node.js
+import sharp from "sharp";
+
+// ../image-processing/dist/shared.js
+var WEBP_HEADER_OFFSET = 8;
+var RIFF_HEADER_LENGTH = 12;
+function startsWithBytes(bytes, signature) {
+  return bytes.length >= signature.length && signature.every((byte, index) => bytes[index] === byte);
+}
+function startsWithAscii(bytes, value) {
+  if (bytes.length < value.length) {
+    return false;
+  }
+  for (let index = 0; index < value.length; index++) {
+    if (bytes[index] !== value.codePointAt(index)) {
+      return false;
+    }
+  }
+  return true;
+}
+function detectSupportedImageFormat(bytes) {
+  if (startsWithBytes(bytes, [255, 216, 255])) {
+    return "jpeg";
+  }
+  if (startsWithBytes(bytes, [137, 80, 78, 71, 13, 10, 26, 10])) {
+    return "png";
+  }
+  if (bytes.length >= RIFF_HEADER_LENGTH && startsWithAscii(bytes, "RIFF") && bytes[WEBP_HEADER_OFFSET] === "W".codePointAt(0) && bytes[WEBP_HEADER_OFFSET + 1] === "E".codePointAt(0) && bytes[WEBP_HEADER_OFFSET + 2] === "B".codePointAt(0) && bytes[WEBP_HEADER_OFFSET + 3] === "P".codePointAt(0)) {
+    return "webp";
+  }
+  return void 0;
+}
+
+// ../image-processing/dist/node.js
+var DEFAULT_WEBP_QUALITY = 80;
+function assertSupportedImage(bytes) {
+  const format = detectSupportedImageFormat(bytes);
+  if (format === void 0) {
+    throw new Error("Unsupported image signature.");
+  }
+  return format;
+}
+async function readImageMetadata(bytes) {
+  const format = assertSupportedImage(bytes);
+  const metadata = await sharp(bytes).metadata();
+  const dimensions = metadata.autoOrient;
+  if (!dimensions.width || !dimensions.height) {
+    throw new Error("Image dimensions could not be determined.");
+  }
+  return {
+    format,
+    height: dimensions.height,
+    width: dimensions.width
+  };
+}
+async function createWebpThumbnail(bytes, options) {
+  assertSupportedImage(bytes);
+  const output = await sharp(bytes).autoOrient().resize(options.width, options.height, {
+    fit: "cover",
+    kernel: sharp.kernel.lanczos3,
+    position: "centre"
+  }).webp({ quality: DEFAULT_WEBP_QUALITY }).toBuffer();
+  return new Uint8Array(output);
+}
+async function convertToWebp(bytes, options) {
+  assertSupportedImage(bytes);
+  const output = await sharp(bytes).autoOrient().webp({ quality: options?.quality ?? DEFAULT_WEBP_QUALITY }).toBuffer();
+  return new Uint8Array(output);
+}
+
+export {
+  readImageMetadata,
+  createWebpThumbnail,
+  convertToWebp
+};

package/dist/chunk-N6TZF755.js

@@ -0,0 +1,102 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+import {
+  makeExportedAt,
+  withTransactionRetry
+} from "./chunk-IWNZQXDG.js";
+
+// ../application/dist/batch/articles-batch-service.js
+var ArticlesBatchApplicationService = class {
+  commandRepository;
+  /**
+   * Creates a new ArticlesBatchApplicationService instance.
+   *
+   * @param commandRepository - The command repository for batch updates
+   */
+  constructor(commandRepository) {
+    this.commandRepository = commandRepository;
+  }
+  /**
+   * Resets articles for a new batch export.
+   *
+   * @param userId - The user ID for tenant isolation
+   * @returns The result containing finalized and marked counts
+   *
+   * @remarks
+   * Delegates to repository's resetStatus which performs two operations
+   * atomically within a single transaction:
+   * 1. Finalize: LAST_UPDATED -> EXPORTED (complete previous batch)
+   * 2. Mark: UNEXPORTED -> LAST_UPDATED (prepare current batch)
+   */
+  async resetArticles(userId) {
+    return this.commandRepository.resetStatus(userId, makeExportedAt());
+  }
+  /**
+   * Reverts articles from LAST_UPDATED back to UNEXPORTED.
+   *
+   * @param userId - The user ID for tenant isolation
+   * @returns The result containing the count of reverted articles
+   *
+   * @remarks
+   * Used to undo a batch marking if something went wrong.
+   * Only affects articles in LAST_UPDATED status.
+   */
+  async revertArticles(userId) {
+    return this.commandRepository.bulkUpdateStatus({
+      userId,
+      fromStatus: "LAST_UPDATED",
+      toStatus: "UNEXPORTED"
+    });
+  }
+};
+
+// ../infrastructure/dist/batch/articles-command-repository.js
+function createArticlesCommandRepository(prisma) {
+  return {
+    async bulkUpdateStatus(params) {
+      const { userId, fromStatus, toStatus, exportedAt } = params;
+      const result = await prisma.article.updateMany({
+        where: {
+          userId,
+          status: fromStatus
+        },
+        data: {
+          status: toStatus,
+          ...exportedAt && { exportedAt }
+        }
+      });
+      return { count: result.count };
+    },
+    async resetStatus(userId, exportedAt) {
+      const [finalized, marked] = await withTransactionRetry(() => prisma.$transaction([
+        prisma.article.updateMany({
+          where: {
+            userId,
+            status: "LAST_UPDATED"
+          },
+          data: {
+            status: "EXPORTED",
+            exportedAt
+          }
+        }),
+        prisma.article.updateMany({
+          where: {
+            userId,
+            status: "UNEXPORTED"
+          },
+          data: {
+            status: "LAST_UPDATED"
+          }
+        })
+      ]));
+      return {
+        finalized: { count: finalized.count },
+        marked: { count: marked.count }
+      };
+    }
+  };
+}
+
+export {
+  ArticlesBatchApplicationService,
+  createArticlesCommandRepository
+};

package/dist/chunk-S5WJ5VXW.js

@@ -0,0 +1,85 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+import {
+  makeExportedAt,
+  withTransactionRetry
+} from "./chunk-IWNZQXDG.js";
+
+// ../application/dist/batch/notes-batch-service.js
+var NotesBatchApplicationService = class {
+  commandRepository;
+  constructor(commandRepository) {
+    this.commandRepository = commandRepository;
+  }
+  /**
+   * Resets notes for a new batch export.
+   *
+   * @remarks
+   * Delegates to repository's resetStatus which performs two operations
+   * atomically within a single transaction.
+   */
+  async resetNotes(userId) {
+    return this.commandRepository.resetStatus(userId, makeExportedAt());
+  }
+  /**
+   * Reverts notes from LAST_UPDATED back to UNEXPORTED.
+   */
+  async revertNotes(userId) {
+    return this.commandRepository.bulkUpdateStatus({
+      userId,
+      fromStatus: "LAST_UPDATED",
+      toStatus: "UNEXPORTED"
+    });
+  }
+};
+
+// ../infrastructure/dist/batch/notes-command-repository.js
+function createNotesCommandRepository(prisma) {
+  return {
+    async bulkUpdateStatus(params) {
+      const { userId, fromStatus, toStatus, exportedAt } = params;
+      const result = await prisma.note.updateMany({
+        where: {
+          userId,
+          status: fromStatus
+        },
+        data: {
+          status: toStatus,
+          ...exportedAt && { exportedAt }
+        }
+      });
+      return { count: result.count };
+    },
+    async resetStatus(userId, exportedAt) {
+      const [finalized, marked] = await withTransactionRetry(() => prisma.$transaction([
+        prisma.note.updateMany({
+          where: {
+            userId,
+            status: "LAST_UPDATED"
+          },
+          data: {
+            status: "EXPORTED",
+            exportedAt
+          }
+        }),
+        prisma.note.updateMany({
+          where: {
+            userId,
+            status: "UNEXPORTED"
+          },
+          data: {
+            status: "LAST_UPDATED"
+          }
+        })
+      ]));
+      return {
+        finalized: { count: finalized.count },
+        marked: { count: marked.count }
+      };
+    }
+  };
+}
+
+export {
+  NotesBatchApplicationService,
+  createNotesCommandRepository
+};

package/dist/chunk-UXGLXHQ6.js

@@ -0,0 +1,40 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+
+// src/lib/html-charset.ts
+var CHARSET_ALIASES = {
+  eucjp: "euc-jp",
+  sjis: "shift_jis",
+  shiftjis: "shift_jis",
+  utf8: "utf-8",
+  xeucjp: "euc-jp",
+  xsjis: "shift_jis"
+};
+function normalizeCharset(charset) {
+  const trimmed = charset.trim().replaceAll(/^['"]|['"]$/gu, "");
+  const normalized = trimmed.toLowerCase().replaceAll(/[^a-z0-9]/gu, "");
+  return CHARSET_ALIASES[normalized] ?? trimmed.toLowerCase();
+}
+function detectHtmlCharset(headers, bytes) {
+  const contentType = headers.get("content-type") ?? "";
+  const headerMatch = /charset\s*=\s*["']?([^"'\s;]+)/iu.exec(contentType);
+  if (headerMatch) return normalizeCharset(headerMatch[1]);
+  const preview = new TextDecoder("windows-1252").decode(
+    bytes.subarray(0, Math.min(4096, bytes.length))
+  );
+  const metaCharset = /<meta\s{1,200}charset=["']?([^"'\s>]+)/iu.exec(preview);
+  if (metaCharset) return normalizeCharset(metaCharset[1]);
+  const metaHttpEquiv = /<meta[^>]{1,500}http-equiv=["']?Content-Type["']?[^>]{1,500}content=["'][^"']{0,500}charset=([^"'\s;]+)/iu.exec(
+    preview
+  );
+  if (metaHttpEquiv) return normalizeCharset(metaHttpEquiv[1]);
+  return "utf-8";
+}
+function decodeHtml(headers, bytes) {
+  return new TextDecoder(detectHtmlCharset(headers, bytes), {
+    fatal: false
+  }).decode(bytes);
+}
+
+export {
+  decodeHtml
+};