@ddse/acm-examples 0.5.0

package/src/data/knowledge.ts

@@ -0,0 +1,77 @@
+import { loadJson, loadText } from './loader.js';
+
+export interface KnowledgeSnippetMeta {
+  id: string;
+  title: string;
+  tags: string[];
+  path: string;
+  summary: string;
+}
+
+interface KnowledgeIndex {
+  snippets: KnowledgeSnippetMeta[];
+}
+
+let cachedIndex: KnowledgeIndex | null = null;
+
+async function loadIndex(): Promise<KnowledgeIndex> {
+  if (cachedIndex) {
+    return cachedIndex;
+  }
+
+  cachedIndex = await loadJson<KnowledgeIndex>('data/knowledge/index.json');
+  return cachedIndex;
+}
+
+export async function searchSnippets(query: string): Promise<KnowledgeSnippetMeta[]> {
+  const index = await loadIndex();
+  const lower = query.toLowerCase();
+  return index.snippets
+    .map(snippet => ({
+      snippet,
+      score: scoreSnippet(snippet, lower),
+    }))
+    .filter(entry => entry.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map(entry => entry.snippet);
+}
+
+function scoreSnippet(snippet: KnowledgeSnippetMeta, query: string): number {
+  const haystack = `${snippet.title} ${snippet.tags.join(' ')} ${snippet.summary}`.toLowerCase();
+  let score = 0;
+  for (const term of query.split(/\s+/)) {
+    if (!term) continue;
+    if (haystack.includes(term)) {
+      score += 2;
+    }
+    for (const tag of snippet.tags) {
+      if (tag.toLowerCase() === term) {
+        score += 3;
+      }
+    }
+  }
+  return score;
+}
+
+export async function loadSnippetContent(docId: string): Promise<string | undefined> {
+  const index = await loadIndex();
+  const snippet = index.snippets.find(item => item.id === docId);
+  if (!snippet) {
+    return undefined;
+  }
+
+  return loadText(pathForSnippet(snippet.path));
+}
+
+function pathForSnippet(relative: string): string {
+  return pathNormalize(`data/knowledge/${relative}`);
+}
+
+function pathNormalize(relative: string): string {
+  return relative.replace(/\\/g, '/');
+}
+
+export async function getSnippetMeta(docId: string): Promise<KnowledgeSnippetMeta | undefined> {
+  const index = await loadIndex();
+  return index.snippets.find(item => item.id === docId);
+}

package/src/data/loader.ts

@@ -0,0 +1,80 @@
+import { readFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import * as path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const jsonCache = new Map<string, unknown>();
+const textCache = new Map<string, string>();
+const pathCache = new Map<string, string>();
+
+function candidatePaths(relativePath: string): string[] {
+  return [
+    path.resolve(process.cwd(), relativePath),
+    path.resolve(__dirname, '..', '..', relativePath),
+    path.resolve(__dirname, '..', '..', '..', relativePath),
+  ];
+}
+
+async function readDataFile(relativePath: string): Promise<{ absolute: string; content: string }> {
+  if (pathCache.has(relativePath)) {
+    const absolute = pathCache.get(relativePath)!;
+    const content = await readFile(absolute, 'utf-8');
+    return { absolute, content };
+  }
+
+  const candidates = candidatePaths(relativePath);
+  let lastError: unknown;
+
+  for (const absolute of candidates) {
+    try {
+      const content = await readFile(absolute, 'utf-8');
+      pathCache.set(relativePath, absolute);
+      return { absolute, content };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw lastError instanceof Error
+    ? lastError
+    : new Error(`Unable to read data file ${relativePath}`);
+}
+
+export async function loadJson<T>(relativePath: string): Promise<T> {
+  if (pathCache.has(relativePath)) {
+    const absolute = pathCache.get(relativePath)!;
+    if (jsonCache.has(absolute)) {
+      return jsonCache.get(absolute) as T;
+    }
+  }
+
+  const { absolute, content } = await readDataFile(relativePath);
+  if (jsonCache.has(absolute)) {
+    return jsonCache.get(absolute) as T;
+  }
+
+  const parsed = JSON.parse(content) as T;
+  jsonCache.set(absolute, parsed);
+  return parsed;
+}
+
+export async function loadText(relativePath: string): Promise<string> {
+  if (pathCache.has(relativePath)) {
+    const absolute = pathCache.get(relativePath)!;
+    if (textCache.has(absolute)) {
+      return textCache.get(absolute)!;
+    }
+  }
+
+  const { absolute, content } = await readDataFile(relativePath);
+  textCache.set(absolute, content);
+  return content;
+}
+
+export function clearDataCaches(): void {
+  jsonCache.clear();
+  textCache.clear();
+  pathCache.clear();
+}