@anokye-labs/kbexplorer-engine 0.1.0

package/dist/chunk-HXAS3BSD.js

@@ -0,0 +1,187 @@
+import { GRAPH_STORE_API_VERSION, GRAPH_STORE_CACHE_KEY_VERSION } from '@anokye-labs/kbexplorer-core';
+
+// src/store/fingerprint.ts
+var GRAPH_STORE_DERIVATION_VERSION = "template-graph-derivation-v3";
+var GRAPH_STORE_PROVIDER_ID = "provider-pipeline";
+function buildProviderResultCacheKey(source, config, data, providerId = GRAPH_STORE_PROVIDER_ID, previousContentHash) {
+  return contentHashFor({
+    apiVersion: GRAPH_STORE_API_VERSION,
+    cacheKeyVersion: GRAPH_STORE_CACHE_KEY_VERSION,
+    derivationVersion: GRAPH_STORE_DERIVATION_VERSION,
+    sourceId: source.id,
+    providerId,
+    previousContentHash,
+    config,
+    data: stableProviderData(data, providerId)
+  }).then((contentHash) => ({
+    scope: "provider-result",
+    providerId,
+    sourceId: sourceIdFor(source, config),
+    contentHash,
+    variant: [
+      GRAPH_STORE_API_VERSION,
+      GRAPH_STORE_CACHE_KEY_VERSION,
+      GRAPH_STORE_DERIVATION_VERSION
+    ].join(":")
+  }));
+}
+function hashProviderResultPrefix(providerId, nodes) {
+  return contentHashFor({
+    apiVersion: GRAPH_STORE_API_VERSION,
+    cacheKeyVersion: GRAPH_STORE_CACHE_KEY_VERSION,
+    derivationVersion: GRAPH_STORE_DERIVATION_VERSION,
+    providerId,
+    nodes
+  });
+}
+function sourceIdFor(source, config) {
+  const sourceConfig = config.source;
+  return [
+    source.id,
+    sourceConfig.owner,
+    sourceConfig.repo,
+    sourceConfig.branch ?? "main",
+    sourceConfig.path ?? ""
+  ].join(":");
+}
+async function contentHashFor(value) {
+  const crypto = globalThis.crypto?.subtle;
+  if (!crypto) {
+    throw new Error("Graph store hashing requires Web Crypto SubtleCrypto support.");
+  }
+  const bytes = new TextEncoder().encode(stableStringify(value));
+  const digest = await crypto.digest("SHA-256", bytes);
+  return {
+    algorithm: "sha256",
+    digest: bytesToHex(new Uint8Array(digest)),
+    encoding: "hex"
+  };
+}
+function bytesToHex(bytes) {
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function stableRepoData(data) {
+  return {
+    repo: data.repo,
+    tree: data.tree.map((item) => ({
+      path: item.path,
+      mode: item.mode,
+      type: item.type,
+      sha: item.sha,
+      size: item.size
+    })),
+    authoredContent: data.authoredContent,
+    nodemapRaw: data.nodemapRaw,
+    nodemapFiles: data.nodemapFiles,
+    nodemapDirs: data.nodemapDirs,
+    issues: data.issues.map((issue) => ({
+      number: issue.number,
+      title: issue.title,
+      body: issue.body,
+      state: issue.state,
+      labels: issue.labels,
+      assignees: issue.assignees,
+      user: issue.user,
+      html_url: issue.html_url,
+      created_at: issue.created_at,
+      updated_at: issue.updated_at
+    })),
+    pullRequests: data.pullRequests,
+    commits: data.commits,
+    branches: data.branches,
+    repoMetadata: data.repoMetadata,
+    releases: data.releases,
+    structuralFiles: data.structuralFiles,
+    structuredNodeMapRaw: data.structuredNodeMapRaw,
+    contentModel: data.contentModel,
+    readme: data.readme
+  };
+}
+function stableProviderData(data, providerId) {
+  switch (providerId) {
+    case "files":
+      return {
+        repo: data.repo,
+        tree: data.tree.map((item) => ({
+          path: item.path,
+          mode: item.mode,
+          type: item.type,
+          sha: item.sha,
+          size: item.size
+        }))
+      };
+    case "authored":
+      return {
+        authoredContent: data.authoredContent,
+        nodemapRaw: data.nodemapRaw,
+        nodemapFiles: data.nodemapFiles,
+        nodemapDirs: data.nodemapDirs
+      };
+    case "work":
+      return {
+        issues: data.issues.map((issue) => ({
+          number: issue.number,
+          title: issue.title,
+          body: issue.body,
+          state: issue.state,
+          labels: issue.labels,
+          assignees: issue.assignees,
+          user: issue.user,
+          html_url: issue.html_url,
+          created_at: issue.created_at,
+          updated_at: issue.updated_at
+        })),
+        pullRequests: data.pullRequests,
+        commits: data.commits,
+        branches: data.branches,
+        repoMetadata: data.repoMetadata,
+        releases: data.releases
+      };
+    case "content-model":
+      return {
+        contentModel: data.contentModel
+      };
+    case "person":
+      return {
+        issues: data.issues.map((issue) => ({
+          number: issue.number,
+          title: issue.title,
+          state: issue.state,
+          assignees: issue.assignees,
+          user: issue.user
+        })),
+        pullRequests: data.pullRequests.map((pr) => ({
+          number: pr.number,
+          title: pr.title,
+          state: pr.state,
+          html_url: pr.html_url,
+          user: pr.user,
+          assignees: pr.assignees
+        }))
+      };
+    case "structural":
+      return {
+        structuralFiles: data.structuralFiles,
+        structuredNodeMapRaw: data.structuredNodeMapRaw
+      };
+    default:
+      return stableRepoData(data);
+  }
+}
+function stableStringify(value) {
+  return JSON.stringify(normalizeForJson(value));
+}
+function normalizeForJson(value) {
+  if (Array.isArray(value)) return value.map(normalizeForJson);
+  if (!value || typeof value !== "object") return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    const item = value[key];
+    if (typeof item !== "function" && item !== void 0) {
+      out[key] = normalizeForJson(item);
+    }
+  }
+  return out;
+}
+
+export { GRAPH_STORE_DERIVATION_VERSION, GRAPH_STORE_PROVIDER_ID, buildProviderResultCacheKey, hashProviderResultPrefix };

package/dist/chunk-IWEURXYH.js

@@ -0,0 +1,273 @@
+import { GRAPH_STORE_DERIVATION_VERSION } from './chunk-HXAS3BSD.js';
+import { formatGraphStoreCacheKey, formatContentHash, GRAPH_STORE_API_VERSION, GRAPH_STORE_CACHE_KEY_VERSION } from '@anokye-labs/kbexplorer-core';
+import initSqlJs from 'sql.js';
+
+var DB_NAME = "kbexplorer-graph-store";
+var STORE_NAME = "sqlite";
+var DB_KEY = "graph-store.sqlite";
+var sqlModuleCache = /* @__PURE__ */ new Map();
+async function loadSqlJs(locateFile) {
+  const cacheKey = locateFile ?? "default";
+  const cached = sqlModuleCache.get(cacheKey);
+  if (cached) return cached;
+  const promise = (async () => {
+    if (locateFile) {
+      return initSqlJs({ locateFile });
+    }
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const { nodeLocateFile } = await import('./node-wasm-VSXBOCPD.js');
+      return initSqlJs({ locateFile: nodeLocateFile() });
+    }
+    return initSqlJs();
+  })();
+  sqlModuleCache.set(cacheKey, promise);
+  return promise;
+}
+async function openPersistedDatabase(byteStore = new IndexedDbSqliteByteStore(), locateFile) {
+  const SQL = await loadSqlJs(locateFile);
+  const bytes = await byteStore.load();
+  const db = bytes ? new SQL.Database(bytes) : new SQL.Database();
+  return {
+    db,
+    persist: async () => {
+      await byteStore.save(db.export());
+    }
+  };
+}
+var MemorySqliteByteStore = class {
+  bytes;
+  async load() {
+    return this.bytes ? new Uint8Array(this.bytes) : void 0;
+  }
+  async save(bytes) {
+    this.bytes = new Uint8Array(bytes);
+  }
+};
+var IndexedDbSqliteByteStore = class {
+  async load() {
+    const db = await openIndexedDb();
+    return requestToPromise(
+      db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(DB_KEY)
+    ).finally(() => db.close());
+  }
+  async save(bytes) {
+    const db = await openIndexedDb();
+    await requestToPromise(
+      db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(bytes, DB_KEY)
+    ).finally(() => db.close());
+  }
+};
+function openIndexedDb() {
+  if (!globalThis.indexedDB) {
+    throw new Error("Graph store SQLite persistence requires IndexedDB support.");
+  }
+  return new Promise((resolve, reject) => {
+    const request = globalThis.indexedDB.open(DB_NAME, 1);
+    request.onupgradeneeded = () => {
+      request.result.createObjectStore(STORE_NAME);
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("Failed to open graph store IndexedDB database."));
+  });
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB graph store request failed."));
+  });
+}
+
+// src/store/sqlite-graph-store.ts
+var SQLITE_SCHEMA_VERSION = "sqlite-graph-store-v1";
+var SQLiteGraphStore = class _SQLiteGraphStore {
+  db;
+  persist;
+  constructor(db, persist) {
+    this.db = db;
+    this.persist = persist;
+    this.migrate();
+  }
+  static async create(byteStore, locateFile) {
+    const { db, persist } = await openPersistedDatabase(byteStore, locateFile);
+    return new _SQLiteGraphStore(db, persist);
+  }
+  async get(key) {
+    const row = this.selectEntry(formatGraphStoreCacheKey(key));
+    if (!row) return void 0;
+    const entry = rowToEntry(row);
+    if (formatGraphStoreCacheKey(entry.key) !== formatGraphStoreCacheKey(key)) {
+      return void 0;
+    }
+    return entry;
+  }
+  async put(entry) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const createdAt = entry.createdAt ?? now;
+    const updatedAt = entry.updatedAt ?? now;
+    this.db.run(
+      `insert into entries (
+        cache_key, key_json, scope, provider_id, source_id, variant, content_hash,
+        value_json, dependencies_json, metadata_json, created_at, updated_at
+      ) values (
+        $cache_key, $key_json, $scope, $provider_id, $source_id, $variant, $content_hash,
+        $value_json, $dependencies_json, $metadata_json, $created_at, $updated_at
+      )
+      on conflict(cache_key) do update set
+        key_json = excluded.key_json,
+        scope = excluded.scope,
+        provider_id = excluded.provider_id,
+        source_id = excluded.source_id,
+        variant = excluded.variant,
+        content_hash = excluded.content_hash,
+        value_json = excluded.value_json,
+        dependencies_json = excluded.dependencies_json,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at`,
+      {
+        $cache_key: formatGraphStoreCacheKey(entry.key),
+        $key_json: JSON.stringify(entry.key),
+        $scope: entry.key.scope,
+        $provider_id: entry.key.providerId,
+        $source_id: entry.key.sourceId ?? null,
+        $variant: entry.key.variant ?? null,
+        $content_hash: formatContentHash(entry.key.contentHash),
+        $value_json: JSON.stringify(entry.value),
+        $dependencies_json: JSON.stringify(entry.dependencies ?? []),
+        $metadata_json: JSON.stringify(entry.metadata ?? {}),
+        $created_at: createdAt,
+        $updated_at: updatedAt
+      }
+    );
+    await this.persist();
+  }
+  async delete(key) {
+    const cacheKey = formatGraphStoreCacheKey(key);
+    const before = this.countEntries();
+    this.db.run("delete from entries where cache_key = $cache_key", { $cache_key: cacheKey });
+    const deleted = this.countEntries() < before;
+    if (deleted) await this.persist();
+    return deleted;
+  }
+  async invalidate(match) {
+    const rows = this.selectEntries();
+    let deleted = 0;
+    for (const row of rows) {
+      const entry = rowToEntry(row);
+      if (matchesInvalidation(entry, match)) {
+        this.db.run("delete from entries where cache_key = $cache_key", { $cache_key: row.cache_key });
+        deleted++;
+      }
+    }
+    if (deleted > 0) await this.persist();
+    return deleted;
+  }
+  migrate() {
+    this.db.run(`
+      create table if not exists metadata (
+        key text primary key,
+        value text not null
+      );
+      create table if not exists entries (
+        cache_key text primary key,
+        key_json text not null,
+        scope text not null,
+        provider_id text not null,
+        source_id text,
+        variant text,
+        content_hash text not null,
+        value_json text not null,
+        dependencies_json text not null,
+        metadata_json text not null,
+        created_at text not null,
+        updated_at text not null
+      );
+      create index if not exists idx_entries_scope on entries(scope);
+      create index if not exists idx_entries_provider on entries(provider_id);
+      create index if not exists idx_entries_source on entries(source_id);
+      create index if not exists idx_entries_variant on entries(variant);
+      create index if not exists idx_entries_content_hash on entries(content_hash);
+    `);
+    this.setMetadata("sqlite_schema_version", SQLITE_SCHEMA_VERSION);
+    this.setMetadata("graph_store_api_version", GRAPH_STORE_API_VERSION);
+    this.setMetadata("graph_store_cache_key_version", GRAPH_STORE_CACHE_KEY_VERSION);
+    this.setMetadata("graph_store_derivation_version", GRAPH_STORE_DERIVATION_VERSION);
+  }
+  setMetadata(key, value) {
+    this.db.run(
+      `insert into metadata (key, value) values ($key, $value)
+       on conflict(key) do update set value = excluded.value`,
+      { $key: key, $value: value }
+    );
+  }
+  selectEntry(cacheKey) {
+    const statement = this.db.prepare(
+      `select cache_key, key_json, value_json, dependencies_json, metadata_json, created_at, updated_at
+       from entries where cache_key = $cache_key limit 1`
+    );
+    try {
+      statement.bind({ $cache_key: cacheKey });
+      if (!statement.step()) return void 0;
+      return statement.getAsObject();
+    } finally {
+      statement.free();
+    }
+  }
+  selectEntries() {
+    const statement = this.db.prepare(
+      "select cache_key, key_json, value_json, dependencies_json, metadata_json, created_at, updated_at from entries"
+    );
+    const rows = [];
+    try {
+      while (statement.step()) {
+        rows.push(statement.getAsObject());
+      }
+      return rows;
+    } finally {
+      statement.free();
+    }
+  }
+  countEntries() {
+    const statement = this.db.prepare("select count(*) as count from entries");
+    try {
+      if (!statement.step()) return 0;
+      const row = statement.getAsObject();
+      return row.count;
+    } finally {
+      statement.free();
+    }
+  }
+};
+function rowToEntry(row) {
+  try {
+    return {
+      key: JSON.parse(row.key_json),
+      value: JSON.parse(row.value_json),
+      dependencies: JSON.parse(row.dependencies_json) ?? [],
+      metadata: JSON.parse(row.metadata_json),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  } catch (err) {
+    throw new Error(`Failed to deserialize graph store entry ${row.cache_key}: ${err instanceof Error ? err.message : String(err)}`, {
+      cause: err
+    });
+  }
+}
+function matchesInvalidation(entry, match) {
+  if (match.scope && entry.key.scope !== match.scope) return false;
+  if (match.providerId && entry.key.providerId !== match.providerId) return false;
+  if (match.sourceId && entry.key.sourceId !== match.sourceId) {
+    const dependencyMatch = entry.dependencies?.some((dep) => dep.sourceId === match.sourceId) ?? false;
+    if (!dependencyMatch) return false;
+  }
+  if (match.variant && entry.key.variant !== match.variant) return false;
+  if (match.contentHash) {
+    const hash = formatContentHash(match.contentHash);
+    const keyMatch = formatContentHash(entry.key.contentHash) === hash;
+    const dependencyMatch = entry.dependencies?.some((dep) => formatContentHash(dep.contentHash) === hash) ?? false;
+    if (!keyMatch && !dependencyMatch) return false;
+  }
+  return true;
+}
+
+export { IndexedDbSqliteByteStore, MemorySqliteByteStore, SQLiteGraphStore, loadSqlJs, openPersistedDatabase };

package/dist/chunk-JNQVSNLC.js

@@ -0,0 +1,55 @@
+// src/identity.ts
+function urnIdentity(namespace, body) {
+  return `urn:${namespace}:${body}`;
+}
+function urnBody(...parts) {
+  return parts.map((part) => encodeURIComponent(String(part))).join(":");
+}
+function assignIdentity(node) {
+  switch (node.source.type) {
+    case "file":
+      return urnIdentity("file", node.source.path);
+    case "authored":
+      return urnIdentity("content", node.id);
+    case "readme":
+      return urnIdentity("content", "readme");
+    case "issue":
+      return urnIdentity("issue", node.source.number);
+    case "pull_request":
+      return urnIdentity("pr", node.source.number);
+    case "commit":
+      return urnIdentity("commit", node.source.sha);
+    case "release":
+      return urnIdentity("release", node.source.tag);
+    case "person":
+      return urnIdentity("person", node.source.alias ?? node.source.login);
+    case "workflow":
+      return urnIdentity("structural", node.source.path);
+    case "external":
+      return urnIdentity("external", urnBody(node.source.provider, node.id));
+    case "structured": {
+      const ldId = node.jsonld?.["@id"];
+      if (typeof ldId === "string" && ldId) return ldId;
+      return void 0;
+    }
+    case "section":
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function shareIdentity(a, b) {
+  return !!(a.identity && b.identity && a.identity === b.identity);
+}
+function buildIdentityIndex(nodes) {
+  const index = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (!n.identity) continue;
+    const existing = index.get(n.identity) ?? [];
+    existing.push(n.id);
+    index.set(n.identity, existing);
+  }
+  return index;
+}
+
+export { assignIdentity, buildIdentityIndex, shareIdentity, urnBody, urnIdentity };

package/dist/chunk-MW4BLXVK.js

@@ -0,0 +1,72 @@
+// src/glob.ts
+function globToRegex(pattern) {
+  let re = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*" && pattern[i + 1] === "*") {
+      re += ".*";
+      i += 1;
+      if (pattern[i + 1] === "/") i += 1;
+    } else if (c === "*") {
+      re += "[^/]*";
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (".+^${}()|[]\\".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+
+// src/sources/build-manifest.ts
+function toManifestPullRequest(pr) {
+  const mapped = {
+    number: pr.number,
+    title: pr.title,
+    body: pr.body,
+    state: pr.state,
+    labels: pr.labels,
+    html_url: pr.html_url,
+    created_at: pr.created_at,
+    updated_at: pr.updated_at
+  };
+  if (pr.head_branch !== void 0) mapped.head_branch = pr.head_branch;
+  return mapped;
+}
+async function buildManifest(source, options = {}) {
+  const data = await source.getRepoData();
+  const manifest = {
+    configRaw: options.configRaw ?? null,
+    authoredContent: data.authoredContent,
+    tree: data.tree,
+    readme: data.readme,
+    issues: data.issues,
+    pullRequests: data.pullRequests.map(toManifestPullRequest),
+    commits: data.commits,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (data.branches.length > 0) manifest.branches = data.branches;
+  if (data.releases.length > 0) manifest.releases = data.releases;
+  if (data.repoMetadata) manifest.repoMetadata = data.repoMetadata;
+  if (data.nodemapRaw !== null) manifest.nodemapRaw = data.nodemapRaw;
+  if (data.nodemapFiles !== void 0) manifest.nodemapFiles = data.nodemapFiles;
+  if (data.nodemapDirs !== void 0) manifest.nodemapDirs = data.nodemapDirs;
+  if (data.structuredNodeMapRaw !== null) manifest.structuredNodeMapRaw = data.structuredNodeMapRaw;
+  if (Object.keys(data.structuralFiles).length > 0) manifest.structuralFiles = data.structuralFiles;
+  if (data.contentModel) manifest.contentModel = data.contentModel;
+  if (data.themeFileRaw) manifest.themeFileRaw = data.themeFileRaw;
+  if (options.augmentFrom) {
+    const live = await options.augmentFrom.getRepoData();
+    manifest.issues = live.issues;
+    manifest.pullRequests = live.pullRequests.map(toManifestPullRequest);
+    manifest.commits = live.commits;
+    if (live.repoMetadata !== null) manifest.repoMetadata = live.repoMetadata;
+    if (live.branches.length > 0) manifest.branches = live.branches;
+    if (live.releases.length > 0) manifest.releases = live.releases;
+  }
+  return manifest;
+}
+
+export { buildManifest, globToRegex };