firebase-dataconnect-bootstrap 1.1.0 → 1.2.0

package/README.md

@@ -1,31 +1,28 @@
 # firebase-dataconnect-bootstrap
 
-Firebase Data Connect の基本構成作成と、Firestore の `onDocumentWritten` Cloud Functions 追加を自動化する CLI です。
+Firebase Data Connect と Cloud Functions のセットアップを自動化する CLI です。  
+初期作成だけでなく、再実行で設定変更（途中更新）もできます。
 
 ## できること
 
-- 対象レポジトリへ `.firebaserc` と `firebase.json` を生成/更新
-- `dataconnect/` 配下に初期ファイル群を作成
-- `functions/` が未初期化なら最小構成で初期化
-- Firestore `onDocumentWritten` 関数を追加して export
-- 必要に応じて `functions/` で `npm install` を実行
+- `.firebaserc` と `firebase.json` の生成/更新
+- `dataconnect/` 初期ファイル生成
+- `functions/` 未初期化時の最小構成作成
+- Firestore `onDocumentWritten` の生成/更新
+- ベクトル検索用 `onRequest` 関数の生成/更新
+- 埋め込み実装差し替え用 `vectorSearchEmbedding` テンプレート生成
+- 前回設定を `.firebase-dataconnect-bootstrap.json` に保存し、次回実行時に再利用
 
 ## 使い方
 
-初回セットアップ:
-
-```bash
-npm install
-npm run build
-```
-
-対話モード:
-
 ```bash
 npx firebase-dataconnect-bootstrap
 ```
 
-非対話モード:
+対話モードは日本語で質問が表示されます。  
+同じリポジトリで再実行すると、保存済み設定を初期値として設定変更できます。
+
+## 非対話モード例
 
 ```bash
 npx firebase-dataconnect-bootstrap \
@@ -37,30 +34,50 @@ npx firebase-dataconnect-bootstrap \
   --location asia-northeast1 \
   --document 'meetingSummaries/{summaryId}' \
   --function onMeetingSummaryWritten \
+  --vector-search \
+  --vector-collection 'meetingSummaries' \
+  --source-text-field 'summary' \
+  --vector-field 'embedding' \
+  --search-fields 'title,summary,createdAt' \
+  --search-function 'searchByVector' \
+  --top-k 5 \
   --install
 ```
 
-## オプション
+## 主なオプション
+
+- `--config <name>`: 設定保存ファイル名（既定: `.firebase-dataconnect-bootstrap.json`）
+- `--vector-search` / `--no-vector-search`: ベクトル検索 scaffold の有効/無効
+- `--vector-collection <path>`: 検索対象コレクション
+- `--source-text-field <name>`: 埋め込み更新対象のテキストフィールド
+- `--vector-field <name>`: ベクトル保存フィールド
+- `--search-fields <csv>`: 検索結果として返すフィールド
+- `--search-function <name>`: 生成する `onRequest` 関数名
+- `--top-k <number>`: 検索時のデフォルト上位件数
+
+## 生成される主な関数
 
-- `--target <path>`: 対象リポジトリ
-- `--project <id>`: Firebase project id
-- `--region <region>`: Functions region
-- `--service <serviceId>`: Data Connect service id
-- `--location <location>`: Data Connect location
-- `--document <path>`: Firestore document path
-- `--function <name>`: 関数の export 名
-- `--install`: `functions` で `npm install` を実行
-- `--no-install`: `npm install` をスキップ
-- `--yes`: 対話なしで実行（`--project` は必須）
+- `firestoreOnDocumentWritten.*`
+  - `sourceTextField` の内容を `embedText` に渡し、`vectorField` へ保存
+- `vectorSearchOnRequest.*`
+  - HTTP リクエストの `vector`（または `query`）でコサイン類似度検索
+- `vectorSearchEmbedding.*`
+  - `embedText` を実装する差し替えポイント（デフォルトは `null` を返す）
 
-## npm 公開
+## npm モジュールとして検索クライアントを使う
 
-1. `npm login`
-2. パッケージ名が未使用か確認
-3. `npm run build`
-4. `npm publish --access public`
+```ts
+import { createVectorSearchClient } from "firebase-dataconnect-bootstrap/search-client";
 
-## 注意点
+const client = createVectorSearchClient({
+  endpoint: "https://<region>-<project>.cloudfunctions.net/searchByVector"
+});
+
+const result = await client.search({
+  query: "議事録の要点",
+  topK: 5
+});
+```
 
-- Data Connect/Firebase CLI の認証やプロジェクト作成そのものは行いません。
-- 既存の `functions` 実装に追記するため、デプロイ前に差分確認を推奨します。
+`query` を使う場合は、Functions 側 `vectorSearchEmbedding.*` の `embedText` 実装が必要です。  
+`vector` を直接渡す場合は `embedText` が未実装でも検索できます。

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function runCli(argv?: string[]): Promise<void>;

package/dist/cli.js

@@ -14,8 +14,17 @@ Options:
   --location <location>      Data Connect location (default: same as region)
   --document <path>          Firestore document path (default: meetingSummaries/{summaryId})
   --function <name>          Function export name (default: onMeetingSummaryWritten)
+  --config <name>            Saved config filename (default: .firebase-dataconnect-bootstrap.json)
   --install                  Run npm install in functions directory
   --no-install               Skip npm install in functions directory
+  --vector-search            Enable vector search scaffolding
+  --no-vector-search         Disable vector search scaffolding
+  --vector-collection <path> Collection path used for vector search
+  --source-text-field <name> Source text field for embedding updates
+  --vector-field <name>      Vector field name
+  --search-fields <csv>      Response fields for search results (comma-separated)
+  --search-function <name>   onRequest function export name for vector search
+  --top-k <number>           Default topK value for vector search
   --yes                      Use defaults and skip prompts where possible
   -h, --help                 Show help
 `;
@@ -29,6 +38,8 @@ function parseArgs(argv) {
         documentPath: undefined,
         functionName: undefined,
         installDependencies: undefined,
+        configFileName: undefined,
+        vectorSearch: {},
         yes: false,
         help: false
     };
@@ -50,6 +61,14 @@ function parseArgs(argv) {
             args.installDependencies = false;
             continue;
         }
+        if (token === "--vector-search") {
+            args.vectorSearch = { ...(args.vectorSearch ?? {}), enabled: true };
+            continue;
+        }
+        if (token === "--no-vector-search") {
+            args.vectorSearch = { ...(args.vectorSearch ?? {}), enabled: false };
+            continue;
+        }
         if (token.startsWith("--target=")) {
             args.targetDir = token.slice("--target=".length);
             continue;
@@ -78,12 +97,66 @@ function parseArgs(argv) {
             args.functionName = token.slice("--function=".length);
             continue;
         }
+        if (token.startsWith("--config=")) {
+            args.configFileName = token.slice("--config=".length);
+            continue;
+        }
+        if (token.startsWith("--vector-collection=")) {
+            args.vectorSearch = {
+                ...(args.vectorSearch ?? {}),
+                collectionPath: token.slice("--vector-collection=".length)
+            };
+            continue;
+        }
+        if (token.startsWith("--source-text-field=")) {
+            args.vectorSearch = {
+                ...(args.vectorSearch ?? {}),
+                sourceTextField: token.slice("--source-text-field=".length)
+            };
+            continue;
+        }
+        if (token.startsWith("--vector-field=")) {
+            args.vectorSearch = {
+                ...(args.vectorSearch ?? {}),
+                vectorField: token.slice("--vector-field=".length)
+            };
+            continue;
+        }
+        if (token.startsWith("--search-fields=")) {
+            args.vectorSearch = {
+                ...(args.vectorSearch ?? {}),
+                returnFields: token
+                    .slice("--search-fields=".length)
+                    .split(",")
+                    .map((field) => field.trim())
+                    .filter(Boolean)
+            };
+            continue;
+        }
+        if (token.startsWith("--search-function=")) {
+            args.vectorSearch = {
+                ...(args.vectorSearch ?? {}),
+                functionName: token.slice("--search-function=".length)
+            };
+            continue;
+        }
+        if (token.startsWith("--top-k=")) {
+            const parsedTopK = Number.parseInt(token.slice("--top-k=".length), 10);
+            if (Number.isNaN(parsedTopK) || parsedTopK <= 0) {
+                throw new Error("--top-k must be a positive integer");
+            }
+            args.vectorSearch = { ...(args.vectorSearch ?? {}), defaultTopK: parsedTopK };
+            continue;
+        }
         const nextValue = argv[i + 1];
-        const useNext = (field) => {
+        const requireNextValue = () => {
             if (!nextValue || nextValue.startsWith("-")) {
                 throw new Error(`Missing value for ${token}`);
             }
-            args[field] = nextValue;
+            return nextValue;
+        };
+        const useNext = (field) => {
+            args[field] = requireNextValue();
             i += 1;
         };
         switch (token) {
@@ -108,6 +181,56 @@ function parseArgs(argv) {
             case "--function":
                 useNext("functionName");
                 break;
+            case "--config":
+                useNext("configFileName");
+                break;
+            case "--vector-collection":
+                args.vectorSearch = {
+                    ...(args.vectorSearch ?? {}),
+                    collectionPath: requireNextValue()
+                };
+                i += 1;
+                break;
+            case "--source-text-field":
+                args.vectorSearch = {
+                    ...(args.vectorSearch ?? {}),
+                    sourceTextField: requireNextValue()
+                };
+                i += 1;
+                break;
+            case "--vector-field":
+                args.vectorSearch = {
+                    ...(args.vectorSearch ?? {}),
+                    vectorField: requireNextValue()
+                };
+                i += 1;
+                break;
+            case "--search-fields":
+                args.vectorSearch = {
+                    ...(args.vectorSearch ?? {}),
+                    returnFields: requireNextValue()
+                        .split(",")
+                        .map((field) => field.trim())
+                        .filter(Boolean)
+                };
+                i += 1;
+                break;
+            case "--search-function":
+                args.vectorSearch = {
+                    ...(args.vectorSearch ?? {}),
+                    functionName: requireNextValue()
+                };
+                i += 1;
+                break;
+            case "--top-k": {
+                const parsedTopK = Number.parseInt(requireNextValue(), 10);
+                if (Number.isNaN(parsedTopK) || parsedTopK <= 0) {
+                    throw new Error("--top-k must be a positive integer");
+                }
+                args.vectorSearch = { ...(args.vectorSearch ?? {}), defaultTopK: parsedTopK };
+                i += 1;
+                break;
+            }
             default:
                 throw new Error(`Unknown option: ${token}`);
         }

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { run } from "./main.js";
+export { runCli } from "./cli.js";
+export { collectConfig } from "./prompt.js";
+export { createVectorSearchClient, searchByVector } from "./search-client.js";
+export type { CliArgs, RunResult, SetupConfig, VectorSearchConfig } from "./types.js";
+export type { SearchByVectorInput, VectorSearchClientOptions, VectorSearchHit, VectorSearchResponse } from "./search-client.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { run } from "./main.js";
+export { runCli } from "./cli.js";
+export { collectConfig } from "./prompt.js";
+export { createVectorSearchClient, searchByVector } from "./search-client.js";

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+import type { RunResult, SetupConfig } from "./types.js";
+export declare function run(config: SetupConfig): Promise<RunResult>;

package/dist/main.js

@@ -50,10 +50,7 @@ function appendIfMissing(content, appendLine) {
 }
 function detectModuleStyle(entryPath, packageJson) {
     const ext = path.extname(entryPath);
-    if (ext === ".ts") {
-        return "esm";
-    }
-    if (ext === ".mjs") {
+    if (ext === ".ts" || ext === ".mjs") {
         return "esm";
     }
     if (ext === ".cjs") {
@@ -64,6 +61,18 @@ function detectModuleStyle(entryPath, packageJson) {
     }
     return "cjs";
 }
+function buildGeneratedImportPath(moduleStyle, extension, moduleBaseName) {
+    if (moduleStyle === "cjs") {
+        if (extension === ".cjs") {
+            return `./${moduleBaseName}.cjs`;
+        }
+        return `./${moduleBaseName}`;
+    }
+    if (extension === ".ts") {
+        return `./${moduleBaseName}.js`;
+    }
+    return `./${moduleBaseName}${extension}`;
+}
 function buildDataconnectYaml(config) {
     return `specVersion: "v1alpha"
 serviceId: "${config.serviceId}"
@@ -124,13 +133,36 @@ function buildMutationsGql() {
 }
 `;
 }
-function buildFunctionModule({ style, functionName, documentPath, region }) {
+function buildEmbeddingModule(style) {
     if (style === "cjs") {
-        return `const { onDocumentWritten } = require("firebase-functions/v2/firestore");
+        return `/**
+ * Replace this function with your embedding provider implementation.
+ * Return a numeric vector (number[]) for the given text.
+ */
+async function embedText(_text) {
+  return null;
+}
+
+module.exports = { embedText };
+`;
+    }
+    return `/**
+ * Replace this function with your embedding provider implementation.
+ * Return a numeric vector (number[]) for the given text.
+ */
+export async function embedText(_text) {
+  return null;
+}
+`;
+}
+function buildFunctionModule({ style, config }) {
+    if (style === "cjs") {
+        if (!config.vectorSearch.enabled) {
+            return `const { onDocumentWritten } = require("firebase-functions/v2/firestore");
 const logger = require("firebase-functions/logger");
 
-const ${functionName} = onDocumentWritten(
-  { document: "${documentPath}", region: "${region}" },
+const ${config.functionName} = onDocumentWritten(
+  { document: "${config.documentPath}", region: "${config.region}" },
   async (event) => {
     logger.info("Firestore onDocumentWritten fired", {
       params: event.params,
@@ -142,14 +174,61 @@ const ${functionName} = onDocumentWritten(
   }
 );
 
-module.exports = { ${functionName} };
+module.exports = { ${config.functionName} };
 `;
+        }
+        return `const { onDocumentWritten } = require("firebase-functions/v2/firestore");
+const logger = require("firebase-functions/logger");
+const { embedText } = require("./vectorSearchEmbedding");
+
+const SOURCE_TEXT_FIELD = ${JSON.stringify(config.vectorSearch.sourceTextField)};
+const VECTOR_FIELD = ${JSON.stringify(config.vectorSearch.vectorField)};
+
+const ${config.functionName} = onDocumentWritten(
+  { document: "${config.documentPath}", region: "${config.region}" },
+  async (event) => {
+    if (!event.data?.after?.exists) {
+      return;
     }
-    return `import { onDocumentWritten } from "firebase-functions/v2/firestore";
+
+    const afterData = event.data.after.data();
+    const sourceText = String(afterData?.[SOURCE_TEXT_FIELD] ?? "").trim();
+    if (!sourceText) {
+      logger.info("Skip embedding update because source text field is empty.", {
+        field: SOURCE_TEXT_FIELD,
+        document: event.data.after.ref.path
+      });
+      return;
+    }
+
+    const vector = await embedText(sourceText);
+    const validVector =
+      Array.isArray(vector) && vector.length > 0 && vector.every((value) => Number.isFinite(value));
+    if (!validVector) {
+      logger.warn("Embedding provider returned an invalid vector.", {
+        field: SOURCE_TEXT_FIELD,
+        document: event.data.after.ref.path
+      });
+      return;
+    }
+
+    await event.data.after.ref.set({ [VECTOR_FIELD]: vector }, { merge: true });
+    logger.info("Updated vector field from source text.", {
+      field: VECTOR_FIELD,
+      document: event.data.after.ref.path
+    });
+  }
+);
+
+module.exports = { ${config.functionName} };
+`;
+    }
+    if (!config.vectorSearch.enabled) {
+        return `import { onDocumentWritten } from "firebase-functions/v2/firestore";
 import * as logger from "firebase-functions/logger";
 
-export const ${functionName} = onDocumentWritten(
-  { document: "${documentPath}", region: "${region}" },
+export const ${config.functionName} = onDocumentWritten(
+  { document: "${config.documentPath}", region: "${config.region}" },
   async (event) => {
     logger.info("Firestore onDocumentWritten fired", {
       params: event.params,
@@ -160,6 +239,267 @@ export const ${functionName} = onDocumentWritten(
     return;
   }
 );
+`;
+    }
+    return `import { onDocumentWritten } from "firebase-functions/v2/firestore";
+import * as logger from "firebase-functions/logger";
+import { embedText } from "./vectorSearchEmbedding.js";
+
+const SOURCE_TEXT_FIELD = ${JSON.stringify(config.vectorSearch.sourceTextField)};
+const VECTOR_FIELD = ${JSON.stringify(config.vectorSearch.vectorField)};
+
+export const ${config.functionName} = onDocumentWritten(
+  { document: "${config.documentPath}", region: "${config.region}" },
+  async (event) => {
+    if (!event.data?.after?.exists) {
+      return;
+    }
+
+    const afterData = event.data.after.data();
+    const sourceText = String(afterData?.[SOURCE_TEXT_FIELD] ?? "").trim();
+    if (!sourceText) {
+      logger.info("Skip embedding update because source text field is empty.", {
+        field: SOURCE_TEXT_FIELD,
+        document: event.data.after.ref.path
+      });
+      return;
+    }
+
+    const vector = await embedText(sourceText);
+    const validVector =
+      Array.isArray(vector) && vector.length > 0 && vector.every((value) => Number.isFinite(value));
+    if (!validVector) {
+      logger.warn("Embedding provider returned an invalid vector.", {
+        field: SOURCE_TEXT_FIELD,
+        document: event.data.after.ref.path
+      });
+      return;
+    }
+
+    await event.data.after.ref.set({ [VECTOR_FIELD]: vector }, { merge: true });
+    logger.info("Updated vector field from source text.", {
+      field: VECTOR_FIELD,
+      document: event.data.after.ref.path
+    });
+  }
+);
+`;
+}
+function buildVectorSearchOnRequestModule(style, config, extension) {
+    const returnFields = JSON.stringify(config.vectorSearch.returnFields);
+    const embeddingImportPath = buildGeneratedImportPath(style, extension, "vectorSearchEmbedding");
+    if (style === "cjs") {
+        return `const { onRequest } = require("firebase-functions/v2/https");
+const logger = require("firebase-functions/logger");
+const admin = require("firebase-admin");
+const { embedText } = require("${embeddingImportPath}");
+
+if (admin.apps.length === 0) {
+  admin.initializeApp();
+}
+
+const db = admin.firestore();
+const COLLECTION_PATH = ${JSON.stringify(config.vectorSearch.collectionPath)};
+const VECTOR_FIELD = ${JSON.stringify(config.vectorSearch.vectorField)};
+const RETURN_FIELDS = ${returnFields};
+const DEFAULT_TOP_K = ${config.vectorSearch.defaultTopK};
+
+function normalizeVector(raw) {
+  if (!Array.isArray(raw)) {
+    return null;
+  }
+  if (raw.length === 0) {
+    return null;
+  }
+  const vector = raw.map((value) => Number(value));
+  if (vector.some((value) => !Number.isFinite(value))) {
+    return null;
+  }
+  return vector;
+}
+
+function cosineSimilarity(left, right) {
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let i = 0; i < left.length; i += 1) {
+    dot += left[i] * right[i];
+    leftNorm += left[i] * left[i];
+    rightNorm += right[i] * right[i];
+  }
+  const denom = Math.sqrt(leftNorm) * Math.sqrt(rightNorm);
+  if (denom === 0) {
+    return Number.NaN;
+  }
+  return dot / denom;
+}
+
+function pickFields(data) {
+  const picked = {};
+  for (const field of RETURN_FIELDS) {
+    if (field in data) {
+      picked[field] = data[field];
+    }
+  }
+  return picked;
+}
+
+const ${config.vectorSearch.functionName} = onRequest(
+  { region: ${JSON.stringify(config.region)}, cors: true },
+  async (req, res) => {
+    try {
+      const payload = req.method === "GET" ? req.query : req.body ?? {};
+      let queryVector = normalizeVector(payload.vector);
+      const queryText = typeof payload.query === "string" ? payload.query.trim() : "";
+      const rawTopK = Number.parseInt(String(payload.topK ?? DEFAULT_TOP_K), 10);
+      const topK = Number.isFinite(rawTopK) && rawTopK > 0 ? rawTopK : DEFAULT_TOP_K;
+
+      if (!queryVector && queryText) {
+        queryVector = normalizeVector(await embedText(queryText));
+      }
+      if (!queryVector) {
+        res.status(400).json({
+          error: "Provide 'vector' (number[]) or implement embedText and send 'query'."
+        });
+        return;
+      }
+
+      const snapshot = await db.collection(COLLECTION_PATH).get();
+      const scored = [];
+      snapshot.forEach((doc) => {
+        const data = doc.data();
+        const candidate = normalizeVector(data[VECTOR_FIELD]);
+        if (!candidate || candidate.length !== queryVector.length) {
+          return;
+        }
+        const score = cosineSimilarity(queryVector, candidate);
+        if (!Number.isFinite(score)) {
+          return;
+        }
+        scored.push({
+          id: doc.id,
+          score,
+          data: pickFields(data)
+        });
+      });
+
+      scored.sort((a, b) => b.score - a.score);
+      res.status(200).json({
+        total: scored.length,
+        results: scored.slice(0, topK)
+      });
+    } catch (error) {
+      logger.error("Vector search request failed", error);
+      res.status(500).json({ error: "Vector search failed." });
+    }
+  }
+);
+
+module.exports = { ${config.vectorSearch.functionName} };
+`;
+    }
+    return `import { onRequest } from "firebase-functions/v2/https";
+import * as logger from "firebase-functions/logger";
+import admin from "firebase-admin";
+import { embedText } from "${embeddingImportPath}";
+
+if (admin.apps.length === 0) {
+  admin.initializeApp();
+}
+
+const db = admin.firestore();
+const COLLECTION_PATH = ${JSON.stringify(config.vectorSearch.collectionPath)};
+const VECTOR_FIELD = ${JSON.stringify(config.vectorSearch.vectorField)};
+const RETURN_FIELDS = ${returnFields};
+const DEFAULT_TOP_K = ${config.vectorSearch.defaultTopK};
+
+function normalizeVector(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return null;
+  }
+  const vector = raw.map((value) => Number(value));
+  if (vector.some((value) => !Number.isFinite(value))) {
+    return null;
+  }
+  return vector;
+}
+
+function cosineSimilarity(left, right) {
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let i = 0; i < left.length; i += 1) {
+    dot += left[i] * right[i];
+    leftNorm += left[i] * left[i];
+    rightNorm += right[i] * right[i];
+  }
+  const denom = Math.sqrt(leftNorm) * Math.sqrt(rightNorm);
+  if (denom === 0) {
+    return Number.NaN;
+  }
+  return dot / denom;
+}
+
+function pickFields(data) {
+  const picked = {};
+  for (const field of RETURN_FIELDS) {
+    if (field in data) {
+      picked[field] = data[field];
+    }
+  }
+  return picked;
+}
+
+export const ${config.vectorSearch.functionName} = onRequest(
+  { region: ${JSON.stringify(config.region)}, cors: true },
+  async (req, res) => {
+    try {
+      const payload = req.method === "GET" ? req.query : req.body ?? {};
+      let queryVector = normalizeVector(payload.vector);
+      const queryText = typeof payload.query === "string" ? payload.query.trim() : "";
+      const rawTopK = Number.parseInt(String(payload.topK ?? DEFAULT_TOP_K), 10);
+      const topK = Number.isFinite(rawTopK) && rawTopK > 0 ? rawTopK : DEFAULT_TOP_K;
+
+      if (!queryVector && queryText) {
+        queryVector = normalizeVector(await embedText(queryText));
+      }
+      if (!queryVector) {
+        res.status(400).json({
+          error: "Provide 'vector' (number[]) or implement embedText and send 'query'."
+        });
+        return;
+      }
+
+      const snapshot = await db.collection(COLLECTION_PATH).get();
+      const scored = [];
+      snapshot.forEach((doc) => {
+        const data = doc.data();
+        const candidate = normalizeVector(data[VECTOR_FIELD]);
+        if (!candidate || candidate.length !== queryVector.length) {
+          return;
+        }
+        const score = cosineSimilarity(queryVector, candidate);
+        if (!Number.isFinite(score)) {
+          return;
+        }
+        scored.push({
+          id: doc.id,
+          score,
+          data: pickFields(data)
+        });
+      });
+
+      scored.sort((a, b) => b.score - a.score);
+      res.status(200).json({
+        total: scored.length,
+        results: scored.slice(0, topK)
+      });
+    } catch (error) {
+      logger.error("Vector search request failed", error);
+      res.status(500).json({ error: "Vector search failed." });
+    }
+  }
+);
 `;
 }
 async function ensureFirebaseRc(targetDir, projectId) {
@@ -266,41 +606,88 @@ admin.initializeApp();
 `, "utf8");
     return { entryPath: defaultEntry, created: defaultEntry };
 }
-async function ensureFunctionExport(targetDir, config, entryRelativePath) {
+async function resolveEntryContext(targetDir, entryRelativePath) {
     const functionsPackage = await readJsonIfExists(path.join(targetDir, "functions", "package.json"));
     const entryFullPath = path.join(targetDir, entryRelativePath);
     const moduleStyle = detectModuleStyle(entryFullPath, functionsPackage);
     const extension = path.extname(entryRelativePath) || ".js";
-    const generatedFileName = `firestoreOnDocumentWritten${extension}`;
-    const generatedRelativePath = path.join(path.dirname(entryRelativePath), generatedFileName);
-    const generatedBaseName = path.basename(generatedFileName, extension);
-    const generatedImportPath = moduleStyle === "esm"
-        ? extension === ".ts"
-            ? `./${generatedBaseName}.js`
-            : `./${generatedFileName}`
-        : `./${generatedBaseName}`;
+    return {
+        moduleStyle,
+        extension,
+        entryRelativePath,
+        entryFullPath
+    };
+}
+async function ensureFunctionExport(targetDir, config, context) {
+    const generatedFileName = `firestoreOnDocumentWritten${context.extension}`;
+    const generatedRelativePath = path.join(path.dirname(context.entryRelativePath), generatedFileName);
+    const generatedImportPath = buildGeneratedImportPath(context.moduleStyle, context.extension, "firestoreOnDocumentWritten");
     const generatedFullPath = path.join(targetDir, generatedRelativePath);
     const functionModuleText = buildFunctionModule({
-        style: moduleStyle,
-        functionName: config.functionName,
-        documentPath: config.documentPath,
-        region: config.region
+        style: context.moduleStyle,
+        config
     });
     await writeFile(generatedFullPath, functionModuleText, "utf8");
-    const entryText = (await readFile(entryFullPath, "utf8")).trimEnd();
-    const exportLine = moduleStyle === "cjs"
+    const entryText = (await readFile(context.entryFullPath, "utf8")).trimEnd();
+    const exportLine = context.moduleStyle === "cjs"
         ? `exports.${config.functionName} = require("${generatedImportPath}").${config.functionName};`
         : `export { ${config.functionName} } from "${generatedImportPath}";`;
     const updated = appendIfMissing(entryText, exportLine);
     if (updated.changed) {
-        await writeFile(entryFullPath, `${updated.content}`, "utf8");
+        await writeFile(context.entryFullPath, updated.content, "utf8");
     }
     return {
         generatedRelativePath: toPosixPath(generatedRelativePath),
-        entryRelativePath: toPosixPath(entryRelativePath),
+        entryRelativePath: toPosixPath(context.entryRelativePath),
         entryUpdated: updated.changed
     };
 }
+async function ensureVectorSearchScaffold(targetDir, config, context) {
+    if (!config.vectorSearch.enabled) {
+        return null;
+    }
+    const folder = path.dirname(context.entryRelativePath);
+    const onRequestFileName = `vectorSearchOnRequest${context.extension}`;
+    const embeddingFileName = `vectorSearchEmbedding${context.extension}`;
+    const onRequestRelativePath = path.join(folder, onRequestFileName);
+    const embeddingRelativePath = path.join(folder, embeddingFileName);
+    const onRequestFullPath = path.join(targetDir, onRequestRelativePath);
+    const embeddingFullPath = path.join(targetDir, embeddingRelativePath);
+    const onRequestImportPath = buildGeneratedImportPath(context.moduleStyle, context.extension, "vectorSearchOnRequest");
+    await writeFile(onRequestFullPath, buildVectorSearchOnRequestModule(context.moduleStyle, config, context.extension), "utf8");
+    const embeddingCreated = await writeTextIfMissing(embeddingFullPath, buildEmbeddingModule(context.moduleStyle));
+    const entryText = (await readFile(context.entryFullPath, "utf8")).trimEnd();
+    const exportLine = context.moduleStyle === "cjs"
+        ? `exports.${config.vectorSearch.functionName} = require("${onRequestImportPath}").${config.vectorSearch.functionName};`
+        : `export { ${config.vectorSearch.functionName} } from "${onRequestImportPath}";`;
+    const updated = appendIfMissing(entryText, exportLine);
+    if (updated.changed) {
+        await writeFile(context.entryFullPath, updated.content, "utf8");
+    }
+    return {
+        generatedRelativePath: toPosixPath(onRequestRelativePath),
+        embeddingRelativePath: toPosixPath(embeddingRelativePath),
+        entryRelativePath: toPosixPath(context.entryRelativePath),
+        entryUpdated: updated.changed,
+        embeddingCreated
+    };
+}
+async function persistBootstrapConfig(targetDir, config) {
+    const filePath = path.join(targetDir, config.configFileName);
+    const persisted = {
+        projectId: config.projectId,
+        region: config.region,
+        serviceId: config.serviceId,
+        location: config.location,
+        documentPath: config.documentPath,
+        functionName: config.functionName,
+        installDependencies: config.installDependencies,
+        configFileName: config.configFileName,
+        vectorSearch: config.vectorSearch
+    };
+    await writeJson(filePath, persisted);
+    return toPosixPath(config.configFileName);
+}
 async function runNpmInstall(functionsDir) {
     await new Promise((resolvePromise, rejectPromise) => {
         const child = spawn("npm", ["install"], {
@@ -350,11 +737,26 @@ export async function run(config) {
     else {
         summaryLines.push(`Using existing ${entryPath}`);
     }
-    const exportResult = await ensureFunctionExport(targetDir, config, entryPath);
-    summaryLines.push(`Updated ${exportResult.generatedRelativePath}`);
-    summaryLines.push(exportResult.entryUpdated
-        ? `Appended export in ${exportResult.entryRelativePath}`
-        : `Export already present in ${exportResult.entryRelativePath}`);
+    const context = await resolveEntryContext(targetDir, entryPath);
+    const documentWriteResult = await ensureFunctionExport(targetDir, config, context);
+    summaryLines.push(`Updated ${documentWriteResult.generatedRelativePath}`);
+    summaryLines.push(documentWriteResult.entryUpdated
+        ? `Appended export in ${documentWriteResult.entryRelativePath}`
+        : `Export already present in ${documentWriteResult.entryRelativePath}`);
+    const vectorSearchResult = await ensureVectorSearchScaffold(targetDir, config, context);
+    if (vectorSearchResult) {
+        summaryLines.push(`Updated ${vectorSearchResult.generatedRelativePath}`);
+        summaryLines.push(vectorSearchResult.embeddingCreated
+            ? `Created ${vectorSearchResult.embeddingRelativePath}`
+            : `Using existing ${vectorSearchResult.embeddingRelativePath}`);
+        summaryLines.push(vectorSearchResult.entryUpdated
+            ? `Appended export in ${vectorSearchResult.entryRelativePath}`
+            : `Vector search export already present in ${vectorSearchResult.entryRelativePath}`);
+    }
+    else {
+        summaryLines.push("Skipped vector search scaffolding");
+    }
+    summaryLines.push(`Updated ${await persistBootstrapConfig(targetDir, config)}`);
     if (config.installDependencies) {
         const functionsDir = path.join(targetDir, "functions");
         await runNpmInstall(functionsDir);

package/dist/prompt.d.ts

@@ -0,0 +1,2 @@
+import type { CliArgs, SetupConfig } from "./types.js";
+export declare function collectConfig(parsed: CliArgs): Promise<SetupConfig>;

package/dist/prompt.js

@@ -1,6 +1,9 @@
 import { resolve } from "node:path";
+import { readFile } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
+const DEFAULT_CONFIG_FILE = ".firebase-dataconnect-bootstrap.json";
+const DEFAULT_RETURN_FIELDS = ["title", "summary", "createdAt"];
 function normalizeFunctionName(name) {
     const cleaned = name.replace(/[^A-Za-z0-9_$]/g, "_");
     if (!cleaned) {
@@ -11,15 +14,64 @@ function normalizeFunctionName(name) {
     }
     return `fn_${cleaned}`;
 }
+function toCsv(fields) {
+    return fields.join(",");
+}
+function parseCsvFields(value) {
+    const fields = value
+        .split(",")
+        .map((field) => field.trim())
+        .filter(Boolean);
+    return fields.length > 0 ? fields : [...DEFAULT_RETURN_FIELDS];
+}
+function deriveCollectionPath(documentPath) {
+    const segments = documentPath.split("/").filter(Boolean);
+    if (segments.length === 0) {
+        return "meetingSummaries";
+    }
+    while (segments.length > 0 && segments[segments.length - 1].startsWith("{")) {
+        segments.pop();
+    }
+    if (segments.length === 0) {
+        return "meetingSummaries";
+    }
+    return segments.join("/");
+}
+function normalizeVectorSearch(partialVectorSearch, documentPath) {
+    const source = partialVectorSearch ?? {};
+    const collectionPath = source.collectionPath?.trim() || deriveCollectionPath(documentPath);
+    const sourceTextField = source.sourceTextField?.trim() || "summary";
+    const vectorField = source.vectorField?.trim() || "embedding";
+    const returnFields = source.returnFields?.length ? source.returnFields : DEFAULT_RETURN_FIELDS;
+    const functionName = normalizeFunctionName(source.functionName?.trim() || "searchByVector");
+    const rawTopK = typeof source.defaultTopK === "number" && Number.isFinite(source.defaultTopK)
+        ? Math.floor(source.defaultTopK)
+        : 5;
+    const defaultTopK = rawTopK > 0 ? rawTopK : 5;
+    const enabled = typeof source.enabled === "boolean" ? source.enabled : false;
+    return {
+        enabled,
+        collectionPath,
+        sourceTextField,
+        vectorField,
+        returnFields,
+        functionName,
+        defaultTopK
+    };
+}
 function normalizeConfig(partial) {
     const targetDir = resolve(partial.targetDir ?? process.cwd());
-    const region = partial.region?.trim() || "us-central1";
     const projectId = partial.projectId?.trim() || "";
+    const region = partial.region?.trim() || "us-central1";
     const serviceId = partial.serviceId?.trim() || `${projectId || "my-project"}-service`;
     const location = partial.location?.trim() || region;
     const documentPath = partial.documentPath?.trim() || "meetingSummaries/{summaryId}";
     const functionName = normalizeFunctionName(partial.functionName?.trim() || "onMeetingSummaryWritten");
-    const installDependencies = typeof partial.installDependencies === "boolean" ? partial.installDependencies : true;
+    const configFileName = partial.configFileName?.trim() || DEFAULT_CONFIG_FILE;
+    const installDependencies = typeof partial.installDependencies === "boolean"
+        ? partial.installDependencies
+        : true;
+    const vectorSearch = normalizeVectorSearch(partial.vectorSearch, documentPath);
     return {
         targetDir,
         projectId,
@@ -28,11 +80,50 @@ function normalizeConfig(partial) {
         location,
         documentPath,
         functionName,
-        installDependencies
+        installDependencies,
+        configFileName,
+        vectorSearch
+    };
+}
+async function loadSavedConfig(targetDir, configFileName) {
+    try {
+        const filePath = resolve(targetDir, configFileName);
+        const raw = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null) {
+            return {};
+        }
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+function mergeConfig(parsed, saved, targetDir) {
+    return {
+        ...saved,
+        targetDir,
+        projectId: parsed.projectId ?? saved.projectId,
+        region: parsed.region ?? saved.region,
+        serviceId: parsed.serviceId ?? saved.serviceId,
+        location: parsed.location ?? saved.location,
+        documentPath: parsed.documentPath ?? saved.documentPath,
+        functionName: parsed.functionName ?? saved.functionName,
+        installDependencies: typeof parsed.installDependencies === "boolean"
+            ? parsed.installDependencies
+            : saved.installDependencies,
+        configFileName: parsed.configFileName ?? saved.configFileName ?? DEFAULT_CONFIG_FILE,
+        vectorSearch: {
+            ...(saved.vectorSearch ?? {}),
+            ...(parsed.vectorSearch ?? {})
+        }
     };
 }
 export async function collectConfig(parsed) {
-    const defaults = normalizeConfig(parsed);
+    const targetDir = resolve(parsed.targetDir ?? process.cwd());
+    const configFileName = parsed.configFileName?.trim() || DEFAULT_CONFIG_FILE;
+    const saved = await loadSavedConfig(targetDir, configFileName);
+    const defaults = normalizeConfig(mergeConfig({ ...parsed, targetDir, configFileName }, { ...saved, targetDir, configFileName: saved.configFileName ?? configFileName }, targetDir));
     if (parsed.yes) {
         if (!defaults.projectId) {
             throw new Error("`--yes` を使う場合は `--project` が必須です。");
@@ -49,6 +140,17 @@ export async function collectConfig(parsed) {
             }
             return value;
         };
+        const askBoolean = async (label, fallback) => {
+            const base = fallback ? "y" : "n";
+            const value = (await ask(label, base, true)).toLowerCase();
+            if (["y", "yes", "true", "1", "はい"].includes(value)) {
+                return true;
+            }
+            if (["n", "no", "false", "0", "いいえ"].includes(value)) {
+                return false;
+            }
+            throw new Error(`${label} は y か n を入力してください。`);
+        };
         console.log("Firebase Data Connect / Cloud Functions セットアップ");
         console.log("");
         const targetDir = resolve(await ask("対象リポジトリのパス", defaults.targetDir, true));
@@ -61,6 +163,26 @@ export async function collectConfig(parsed) {
         const functionName = normalizeFunctionName(rawFunctionName);
         const installRaw = await ask("functions ディレクトリで npm install を実行しますか？ (y/n)", defaults.installDependencies ? "y" : "n", true);
         const installDependencies = installRaw.toLowerCase().startsWith("y");
+        const vectorEnabled = await askBoolean("ベクトル検索と onRequest 検索関数を有効化しますか？ (y/n)", defaults.vectorSearch.enabled);
+        let vectorCollectionPath = defaults.vectorSearch.collectionPath;
+        let sourceTextField = defaults.vectorSearch.sourceTextField;
+        let vectorField = defaults.vectorSearch.vectorField;
+        let returnFields = defaults.vectorSearch.returnFields;
+        let searchFunctionName = defaults.vectorSearch.functionName;
+        let defaultTopK = defaults.vectorSearch.defaultTopK;
+        if (vectorEnabled) {
+            vectorCollectionPath = await ask("ベクトル検索対象のコレクションパス", defaults.vectorSearch.collectionPath, true);
+            sourceTextField = await ask("埋め込み作成対象のテキストフィールド", defaults.vectorSearch.sourceTextField, true);
+            vectorField = await ask("ベクトル保存先フィールド名", defaults.vectorSearch.vectorField, true);
+            const returnFieldsCsv = await ask("検索結果に返すフィールド（カンマ区切り）", toCsv(defaults.vectorSearch.returnFields), true);
+            returnFields = parseCsvFields(returnFieldsCsv);
+            searchFunctionName = normalizeFunctionName(await ask("onRequest 検索関数名", defaults.vectorSearch.functionName, true));
+            const defaultTopKText = await ask("ベクトル検索のデフォルト topK", String(defaults.vectorSearch.defaultTopK), true);
+            defaultTopK = Number.parseInt(defaultTopKText, 10);
+            if (Number.isNaN(defaultTopK) || defaultTopK <= 0) {
+                throw new Error("topK は 1 以上の整数で入力してください。");
+            }
+        }
         return {
             targetDir,
             projectId,
@@ -69,7 +191,17 @@ export async function collectConfig(parsed) {
             location,
             documentPath,
             functionName,
-            installDependencies
+            installDependencies,
+            configFileName: defaults.configFileName,
+            vectorSearch: {
+                enabled: vectorEnabled,
+                collectionPath: vectorCollectionPath,
+                sourceTextField,
+                vectorField,
+                returnFields,
+                functionName: searchFunctionName,
+                defaultTopK
+            }
         };
     }
     finally {

package/dist/search-client.d.ts

@@ -0,0 +1,40 @@
+export interface VectorSearchHit {
+    id: string;
+    score: number;
+    data: Record<string, unknown>;
+}
+export interface VectorSearchResponse {
+    total: number;
+    results: VectorSearchHit[];
+}
+export interface SearchByVectorInput {
+    endpoint: string;
+    vector?: number[];
+    query?: string;
+    topK?: number;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+interface MinimalResponse {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+type MinimalFetch = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+    signal?: AbortSignal;
+}) => Promise<MinimalResponse>;
+export declare function searchByVector(input: SearchByVectorInput, fetchImpl?: MinimalFetch): Promise<VectorSearchResponse>;
+export interface VectorSearchClientOptions {
+    endpoint: string;
+    headers?: Record<string, string>;
+    fetchImpl?: MinimalFetch;
+}
+export declare function createVectorSearchClient(options: VectorSearchClientOptions): {
+    search: (input: Omit<SearchByVectorInput, "endpoint">) => Promise<VectorSearchResponse>;
+};
+export {};

package/dist/search-client.js

@@ -0,0 +1,56 @@
+const defaultFetch = (url, init) => fetch(url, init);
+function validateVector(vector) {
+    if (!vector) {
+        return undefined;
+    }
+    if (vector.length === 0 || vector.some((value) => !Number.isFinite(value))) {
+        throw new Error("`vector` must be a non-empty number array.");
+    }
+    return vector;
+}
+export async function searchByVector(input, fetchImpl = defaultFetch) {
+    const endpoint = input.endpoint.trim();
+    if (!endpoint) {
+        throw new Error("`endpoint` is required.");
+    }
+    const payload = {
+        topK: input.topK
+    };
+    const vector = validateVector(input.vector);
+    if (vector) {
+        payload.vector = vector;
+    }
+    if (input.query) {
+        payload.query = input.query;
+    }
+    const response = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            ...(input.headers ?? {})
+        },
+        body: JSON.stringify(payload),
+        signal: input.signal
+    });
+    if (!response.ok) {
+        const message = await response.text();
+        throw new Error(`Vector search request failed (${response.status} ${response.statusText}): ${message}`);
+    }
+    const body = (await response.json());
+    return {
+        total: typeof body.total === "number" ? body.total : 0,
+        results: Array.isArray(body.results) ? body.results : []
+    };
+}
+export function createVectorSearchClient(options) {
+    return {
+        search: (input) => searchByVector({
+            ...input,
+            endpoint: options.endpoint,
+            headers: {
+                ...(options.headers ?? {}),
+                ...(input.headers ?? {})
+            }
+        }, options.fetchImpl)
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+export interface CliArgs {
+    targetDir?: string;
+    projectId?: string;
+    region?: string;
+    serviceId?: string;
+    location?: string;
+    documentPath?: string;
+    functionName?: string;
+    installDependencies?: boolean;
+    configFileName?: string;
+    vectorSearch?: Partial<VectorSearchConfig>;
+    yes: boolean;
+    help: boolean;
+}
+export interface VectorSearchConfig {
+    enabled: boolean;
+    collectionPath: string;
+    sourceTextField: string;
+    vectorField: string;
+    returnFields: string[];
+    functionName: string;
+    defaultTopK: number;
+}
+export interface SetupConfig {
+    targetDir: string;
+    projectId: string;
+    region: string;
+    serviceId: string;
+    location: string;
+    documentPath: string;
+    functionName: string;
+    installDependencies: boolean;
+    configFileName: string;
+    vectorSearch: VectorSearchConfig;
+}
+export interface RunResult {
+    targetDir: string;
+    summaryLines: string[];
+}

package/package.json

@@ -1,12 +1,24 @@
 {
   "name": "firebase-dataconnect-bootstrap",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Bootstrap Firebase Data Connect and Firestore onDocumentWritten function setup in any repository.",
   "type": "module",
   "bin": {
     "firebase-dataconnect-bootstrap": "bin/firebase-dataconnect-bootstrap.js"
   },
-  "main": "dist/main.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./search-client": {
+      "types": "./dist/search-client.d.ts",
+      "import": "./dist/search-client.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "bin",
     "dist",
@@ -26,7 +38,8 @@
     "dataconnect",
     "firestore",
     "cloud-functions",
-    "cli"
+    "cli",
+    "vector-search"
   ],
   "author": "",
   "license": "MIT",