@hiveai/core 0.3.3 → 0.4.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/schema.ts
 import { z } from "zod";
-var MemoryScopeSchema = z.enum(["personal", "team", "module"]);
+var MemoryScopeSchema = z.enum(["personal", "team", "module", "shared"]);
 var MemoryStatusSchema = z.enum([
   "draft",
   "proposed",
@@ -50,6 +50,16 @@ var MemoryFrontmatterSchema = z.object({
   (data) => data.scope !== "module" || !!data.module,
   { message: "module name is required when scope is 'module'", path: ["module"] }
 );
+var CrossRepoProvenanceSchema = z.object({
+  source_name: z.string(),
+  // the crossRepoSources name from haive.config.json
+  source_path: z.string(),
+  // original file path in the source repo
+  source_id: z.string(),
+  // original memory id
+  imported_at: z.string()
+  // ISO timestamp of import
+}).optional();
 
 // src/parser.ts
 import matter from "gray-matter";
@@ -108,7 +118,8 @@ function buildFrontmatter(input) {
     created_at: now.toISOString(),
     expires_when: null,
     topic: input.topic,
-    revision_count: 0
+    revision_count: 0,
+    related_ids: input.relatedIds ?? []
   });
 }
 
@@ -947,12 +958,585 @@ async function loadConfig(paths) {
 async function saveConfig(paths, config) {
   await writeFile3(configPath(paths), JSON.stringify(config, null, 2) + "\n", "utf8");
 }
+
+// src/cross-repo.ts
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import path8 from "path";
+import { spawnSync } from "child_process";
+async function loadImportMap(cacheDir) {
+  const mapPath = path8.join(cacheDir, "import-map.json");
+  if (!existsSync6(mapPath)) return {};
+  try {
+    return JSON.parse(await readFile6(mapPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function saveImportMap(cacheDir, map) {
+  await writeFile4(path8.join(cacheDir, "import-map.json"), JSON.stringify(map, null, 2) + "\n", "utf8");
+}
+async function pullCrossRepoSources(paths, config, projectRoot) {
+  const sources = config.crossRepoSources ?? [];
+  if (sources.length === 0) return [];
+  const reports = [];
+  for (const source of sources) {
+    reports.push(await pullFromSource(paths, source, projectRoot));
+  }
+  return reports;
+}
+async function pullFromSource(paths, source, projectRoot) {
+  const report = {
+    source: source.name,
+    imported: [],
+    updated: [],
+    skipped: [],
+    errors: []
+  };
+  let sourceRoot = null;
+  if (source.path) {
+    const resolved = path8.resolve(projectRoot, source.path);
+    if (!existsSync6(resolved)) {
+      report.errors.push(`Path not found: ${resolved}`);
+      return report;
+    }
+    sourceRoot = resolved;
+  } else if (source.git) {
+    sourceRoot = await cloneOrFetchGitSource(source, paths, report);
+    if (!sourceRoot) return report;
+  } else {
+    report.errors.push(`Source "${source.name}" has neither path nor git \u2014 skipping.`);
+    return report;
+  }
+  const sourcePaths = resolveHaivePaths(sourceRoot);
+  if (!existsSync6(sourcePaths.memoriesDir)) {
+    report.errors.push(`No .ai/memories/ found at ${sourceRoot}`);
+    return report;
+  }
+  const sourceMemories = (await loadMemoriesFromDir(sourcePaths.memoriesDir)).filter(
+    ({ memory }) => {
+      const fm = memory.frontmatter;
+      if (fm.scope !== "shared") return false;
+      if (fm.status === "rejected" || fm.status === "deprecated") return false;
+      if (source.filter?.tags && source.filter.tags.length > 0) {
+        const hasTag = source.filter.tags.some((t) => fm.tags.includes(t));
+        if (!hasTag) return false;
+      }
+      if (source.filter?.types && source.filter.types.length > 0) {
+        if (!source.filter.types.includes(fm.type)) return false;
+      }
+      return true;
+    }
+  );
+  if (sourceMemories.length === 0) {
+    report.skipped.push("no shared memories found in source");
+    return report;
+  }
+  const destDir = path8.join(paths.memoriesDir, "shared", source.name);
+  await mkdir3(destDir, { recursive: true });
+  const cacheDir = path8.join(paths.haiveDir, ".cache", "cross-repo", source.name);
+  await mkdir3(cacheDir, { recursive: true });
+  const importMap = await loadImportMap(cacheDir);
+  const mapDirty = false;
+  let dirty = mapDirty;
+  for (const { memory } of sourceMemories) {
+    const fm = memory.frontmatter;
+    const sourceId = fm.id;
+    const importTag = `cross-repo:${source.name}`;
+    const tags = [.../* @__PURE__ */ new Set([...fm.tags, importTag])];
+    const importedBodyPrefix = `> **Imported from \`${source.name}\`** (original id: \`${sourceId}\`)  
+> Imported at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+`;
+    const existingLocalPath = importMap[sourceId];
+    if (existingLocalPath && existsSync6(existingLocalPath)) {
+      const existingFiles = await loadMemoriesFromDir(destDir);
+      const existingEntry = existingFiles.find(({ filePath }) => filePath === existingLocalPath);
+      const sourceBodyStripped = memory.body.trim();
+      const existingBodyStripped = (existingEntry?.memory.body ?? "").replace(/^>.*\n>.*\n\n/m, "").trim();
+      if (existingBodyStripped === sourceBodyStripped) {
+        report.skipped.push(sourceId);
+        continue;
+      }
+      const updatedBody = importedBodyPrefix + memory.body;
+      if (existingEntry) {
+        await writeFile4(
+          existingLocalPath,
+          serializeMemory({ frontmatter: existingEntry.memory.frontmatter, body: updatedBody }),
+          "utf8"
+        );
+      }
+      report.updated.push(sourceId);
+    } else {
+      const slug = `${source.name}-${fm.id.slice(0, 40)}`;
+      const newFm = buildFrontmatter({
+        type: fm.type,
+        slug,
+        scope: "team",
+        module: void 0,
+        status: "validated",
+        tags,
+        domain: fm.domain,
+        author: fm.author,
+        paths: fm.anchor.paths,
+        symbols: fm.anchor.symbols,
+        commit: fm.anchor.commit,
+        topic: fm.topic ? `${source.name}:${fm.topic}` : void 0
+      });
+      const body = importedBodyPrefix + memory.body;
+      const destPath = path8.join(destDir, `${newFm.id}.md`);
+      await writeFile4(destPath, serializeMemory({ frontmatter: newFm, body }), "utf8");
+      importMap[sourceId] = destPath;
+      dirty = true;
+      report.imported.push(sourceId);
+    }
+  }
+  if (dirty) await saveImportMap(cacheDir, importMap);
+  return report;
+}
+async function cloneOrFetchGitSource(source, paths, report) {
+  const cacheDir = path8.join(paths.haiveDir, ".cache", "cross-repo", source.name);
+  await mkdir3(cacheDir, { recursive: true });
+  if (existsSync6(path8.join(cacheDir, ".git"))) {
+    const result = spawnSync("git", ["fetch", "--depth=1", "origin"], {
+      cwd: cacheDir,
+      encoding: "utf8"
+    });
+    if (result.status !== 0) {
+      report.errors.push(`git fetch failed for ${source.name}: ${result.stderr}`);
+      return null;
+    }
+    spawnSync("git", ["reset", "--hard", "FETCH_HEAD"], { cwd: cacheDir });
+  } else {
+    const result = spawnSync(
+      "git",
+      ["clone", "--depth=1", source.git, "."],
+      { cwd: cacheDir, encoding: "utf8" }
+    );
+    if (result.status !== 0) {
+      report.errors.push(`git clone failed for ${source.name}: ${result.stderr}`);
+      return null;
+    }
+  }
+  return cacheDir;
+}
+
+// src/dep-tracker.ts
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
+import path9 from "path";
+function parsePackageJson(content) {
+  try {
+    const pkg = JSON.parse(content);
+    return {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+      ...pkg.peerDependencies
+    };
+  } catch {
+    return {};
+  }
+}
+function parseGoMod(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const m = line.trim().match(/^(\S+)\s+(v[\d.]+)/);
+    if (m?.[1] && m[2]) result[m[1]] = m[2];
+  }
+  return result;
+}
+function parseRequirementsTxt(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const clean = (line.split("#")[0] ?? "").trim();
+    const m = clean.match(/^([A-Za-z0-9_.-]+)[=><~!]+(.+)$/);
+    if (m?.[1] && m[2]) result[m[1].toLowerCase()] = m[2].trim();
+  }
+  return result;
+}
+function parseCargotoml(content) {
+  const result = {};
+  let inDeps = false;
+  for (const line of content.split("\n")) {
+    if (/^\[(dependencies|dev-dependencies|build-dependencies)\]/.test(line.trim())) {
+      inDeps = true;
+      continue;
+    }
+    if (line.startsWith("[") && !line.includes("dependencies")) {
+      inDeps = false;
+      continue;
+    }
+    if (!inDeps) continue;
+    const simple = line.match(/^(\w[\w-]*)\s*=\s*"([^"]+)"/);
+    if (simple?.[1] && simple[2]) {
+      result[simple[1]] = simple[2];
+      continue;
+    }
+    const table = line.match(/^(\w[\w-]*)\s*=\s*\{[^}]*version\s*=\s*"([^"]+)"/);
+    if (table?.[1] && table[2]) result[table[1]] = table[2];
+  }
+  return result;
+}
+function parsePomXml(content) {
+  const result = {};
+  const depRe = /<dependency>[\s\S]*?<groupId>([^<]+)<\/groupId>[\s\S]*?<artifactId>([^<]+)<\/artifactId>[\s\S]*?<version>([^<]+)<\/version>[\s\S]*?<\/dependency>/g;
+  let m;
+  while ((m = depRe.exec(content)) !== null) {
+    if (m[1] && m[2] && m[3]) {
+      result[`${m[1].trim()}:${m[2].trim()}`] = m[3].trim();
+    }
+  }
+  return result;
+}
+var KNOWN_MANIFESTS = [
+  { name: "package.json", parser: parsePackageJson },
+  { name: "go.mod", parser: parseGoMod },
+  { name: "requirements.txt", parser: parseRequirementsTxt },
+  { name: "Cargo.toml", parser: parseCargotoml },
+  { name: "pom.xml", parser: parsePomXml }
+];
+function getParser(file) {
+  const base = path9.basename(file);
+  return KNOWN_MANIFESTS.find((m) => m.name === base)?.parser ?? null;
+}
+function extractMajor(version) {
+  const clean = version.replace(/^[^0-9]*/, "");
+  const firstPart = clean.split(".")[0];
+  if (!firstPart) return null;
+  const n = parseInt(firstPart, 10);
+  return isNaN(n) ? null : n;
+}
+function isMajorBump(from, to) {
+  const fromMajor = extractMajor(from);
+  const toMajor = extractMajor(to);
+  if (fromMajor === null || toMajor === null) return false;
+  return toMajor > fromMajor;
+}
+function resolveManifestFiles(projectRoot, configuredFiles) {
+  if (configuredFiles !== void 0) {
+    return configuredFiles.map((f) => path9.resolve(projectRoot, f)).filter(existsSync7);
+  }
+  return KNOWN_MANIFESTS.map(({ name }) => path9.join(projectRoot, name)).filter(existsSync7);
+}
+async function trackDependencies(projectRoot, haiveDir, manifestFiles) {
+  const contractsDir = path9.join(haiveDir, "contracts");
+  await mkdir4(contractsDir, { recursive: true });
+  const results = [];
+  for (const manifestPath of manifestFiles) {
+    const parser = getParser(manifestPath);
+    if (!parser) continue;
+    const content = await readFile7(manifestPath, "utf8");
+    const currentDeps = parser(content);
+    const lockName = `deps-${path9.basename(manifestPath)}.lock`;
+    const lockPath = path9.join(contractsDir, lockName);
+    if (!existsSync7(lockPath)) {
+      const snapshot2 = {
+        file: path9.relative(projectRoot, manifestPath),
+        format: path9.basename(manifestPath),
+        captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+        deps: currentDeps
+      };
+      await writeFile5(lockPath, JSON.stringify(snapshot2, null, 2) + "\n", "utf8");
+      continue;
+    }
+    const snapshot = JSON.parse(await readFile7(lockPath, "utf8"));
+    const changes = [];
+    for (const [name, currentVer] of Object.entries(currentDeps)) {
+      const prevVer = snapshot.deps[name];
+      if (prevVer && prevVer !== currentVer) {
+        changes.push({
+          name,
+          from: prevVer,
+          to: currentVer,
+          isMajorBump: isMajorBump(prevVer, currentVer)
+        });
+      }
+    }
+    if (changes.length > 0) {
+      results.push({ file: path9.relative(projectRoot, manifestPath), changes });
+      const updated = {
+        ...snapshot,
+        captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+        deps: currentDeps
+      };
+      await writeFile5(lockPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    }
+  }
+  return results;
+}
+
+// src/contract-watcher.ts
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile8, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
+import path10 from "path";
+import crypto from "crypto";
+function sha256(content) {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+function parseOpenApi(content, file) {
+  try {
+    let doc;
+    if (file.endsWith(".yaml") || file.endsWith(".yml")) {
+      doc = parseYamlPaths(content);
+    } else {
+      doc = JSON.parse(content);
+    }
+    const paths = doc.paths ?? {};
+    const endpoints = [];
+    for (const [routePath, methods] of Object.entries(paths)) {
+      for (const method of Object.keys(methods)) {
+        if (["get", "post", "put", "patch", "delete", "head", "options"].includes(method)) {
+          endpoints.push(`${method.toUpperCase()} ${routePath}`);
+        }
+      }
+    }
+    const schemas = doc.components?.schemas ?? doc.definitions ?? {};
+    const types = Object.keys(schemas);
+    const fields = {};
+    for (const [typeName, schema] of Object.entries(schemas)) {
+      const props = schema.properties ?? {};
+      fields[typeName] = Object.keys(props);
+    }
+    return { endpoints, types, fields };
+  } catch {
+    return {};
+  }
+}
+function parseYamlPaths(content) {
+  const result = {};
+  let currentPath = "";
+  for (const line of content.split("\n")) {
+    const pathMatch = line.match(/^  (\/[^\s:]+):/);
+    if (pathMatch?.[1]) {
+      currentPath = pathMatch[1];
+      result[currentPath] = {};
+      continue;
+    }
+    if (currentPath) {
+      const methodMatch = line.match(/^    (get|post|put|patch|delete|head|options):/);
+      if (methodMatch?.[1]) (result[currentPath] ??= {})[methodMatch[1]] = true;
+    }
+  }
+  return { paths: result };
+}
+function parseGraphQL(content) {
+  const types = [];
+  const fields = {};
+  let currentType = "";
+  for (const line of content.split("\n")) {
+    const typeMatch = line.match(/^(?:type|interface|union|enum|input)\s+(\w+)/);
+    if (typeMatch?.[1]) {
+      currentType = typeMatch[1];
+      types.push(currentType);
+      fields[currentType] = [];
+      continue;
+    }
+    if (currentType && line.trim().startsWith("}")) {
+      currentType = "";
+      continue;
+    }
+    if (currentType) {
+      const fieldMatch = line.match(/^\s+(\w+)\s*[:(]/);
+      if (fieldMatch?.[1]) (fields[currentType] ??= []).push(fieldMatch[1]);
+    }
+  }
+  return { types, fields };
+}
+function parseProto(content) {
+  const types = [];
+  const fields = {};
+  let currentMsg = "";
+  for (const line of content.split("\n")) {
+    const msgMatch = line.match(/^(?:message|service|enum)\s+(\w+)/);
+    if (msgMatch?.[1]) {
+      currentMsg = msgMatch[1];
+      types.push(currentMsg);
+      fields[currentMsg] = [];
+      continue;
+    }
+    if (currentMsg && line.trim() === "}") {
+      currentMsg = "";
+      continue;
+    }
+    if (currentMsg) {
+      const fieldMatch = line.match(/^\s+(?:optional|required|repeated)?\s*\w+\s+(\w+)\s*=/);
+      if (fieldMatch?.[1]) (fields[currentMsg] ??= []).push(fieldMatch[1]);
+      const rpcMatch = line.match(/^\s+rpc\s+(\w+)/);
+      if (rpcMatch?.[1]) (fields[currentMsg] ??= []).push(`rpc:${rpcMatch[1]}`);
+    }
+  }
+  return { types, fields };
+}
+function parseTypescript(content) {
+  const types = [];
+  const fields = {};
+  let currentType = "";
+  let braceDepth = 0;
+  for (const line of content.split("\n")) {
+    const exportMatch = line.match(/^export\s+(?:declare\s+)?(?:interface|class|type|enum)\s+(\w+)/);
+    if (exportMatch?.[1]) {
+      currentType = exportMatch[1];
+      types.push(currentType);
+      fields[currentType] = [];
+    }
+    if (currentType) {
+      braceDepth += (line.match(/{/g) ?? []).length;
+      braceDepth -= (line.match(/}/g) ?? []).length;
+      if (braceDepth <= 0 && line.includes("}")) {
+        currentType = "";
+        braceDepth = 0;
+        continue;
+      }
+      const memberMatch = line.match(/^\s+(?:readonly\s+)?(\w+)\s*[?:(!]/);
+      if (memberMatch?.[1] && currentType) (fields[currentType] ??= []).push(memberMatch[1]);
+    }
+  }
+  return { types, fields };
+}
+function parseByFormat(content, format, filePath) {
+  switch (format) {
+    case "openapi":
+      return parseOpenApi(content, filePath);
+    case "graphql":
+      return parseGraphQL(content);
+    case "proto":
+      return parseProto(content);
+    case "typescript":
+      return parseTypescript(content);
+    case "json-schema": {
+      try {
+        const schema = JSON.parse(content);
+        const types = Object.keys(schema.definitions ?? schema.properties ?? {});
+        return { types };
+      } catch {
+        return {};
+      }
+    }
+    default:
+      return {};
+  }
+}
+function diffLists(before, after, kind) {
+  const changes = [];
+  const beforeSet = new Set(before);
+  const afterSet = new Set(after);
+  for (const item of beforeSet) {
+    if (!afterSet.has(item)) {
+      const isBreaking = kind === "endpoint" || kind === "field" || kind === "type";
+      changes.push({
+        kind: `${kind}_removed`,
+        description: `${kind} removed: ${item}`,
+        severity: isBreaking ? "breaking" : "unknown"
+      });
+    }
+  }
+  for (const item of afterSet) {
+    if (!beforeSet.has(item)) {
+      changes.push({
+        kind: `${kind}_added`,
+        description: `${kind} added: ${item}`,
+        severity: "additive"
+      });
+    }
+  }
+  return changes;
+}
+function diffSnapshots(before, after) {
+  if (before.hash === after.hash) return [];
+  const changes = [];
+  if (before.endpoints && after.endpoints) {
+    changes.push(...diffLists(before.endpoints, after.endpoints, "endpoint"));
+  }
+  if (before.types && after.types) {
+    changes.push(...diffLists(before.types, after.types, "type"));
+  }
+  if (before.fields && after.fields) {
+    const allTypes = /* @__PURE__ */ new Set([...Object.keys(before.fields), ...Object.keys(after.fields)]);
+    for (const typeName of allTypes) {
+      const beforeFields = before.fields[typeName] ?? [];
+      const afterFields = after.fields[typeName] ?? [];
+      const fieldChanges = diffLists(beforeFields, afterFields, "field");
+      for (const fc of fieldChanges) {
+        changes.push({ ...fc, description: `${typeName}.${fc.description}` });
+      }
+    }
+  }
+  if (changes.length === 0) {
+    changes.push({
+      kind: "content_changed",
+      description: "Contract file content changed (no structured diff available)",
+      severity: "unknown"
+    });
+  }
+  return changes;
+}
+function contractLockPath(haiveDir, name) {
+  return path10.join(haiveDir, "contracts", `${name}.lock`);
+}
+async function snapshotContract(projectRoot, haiveDir, contract) {
+  const filePath = path10.resolve(projectRoot, contract.path);
+  if (!existsSync8(filePath)) {
+    throw new Error(`Contract file not found: ${filePath}`);
+  }
+  const content = await readFile8(filePath, "utf8");
+  const parsed = parseByFormat(content, contract.format, filePath);
+  const snapshot = {
+    name: contract.name,
+    path: contract.path,
+    format: contract.format,
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    hash: sha256(content),
+    ...parsed
+  };
+  const contractsDir = path10.join(haiveDir, "contracts");
+  await mkdir5(contractsDir, { recursive: true });
+  await writeFile6(contractLockPath(haiveDir, contract.name), JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+  return snapshot;
+}
+async function diffContract(projectRoot, haiveDir, contract) {
+  const filePath = path10.resolve(projectRoot, contract.path);
+  if (!existsSync8(filePath)) {
+    return { contract: contract.name, file: contract.path, changes: [], unchanged: true };
+  }
+  const lockPath = contractLockPath(haiveDir, contract.name);
+  if (!existsSync8(lockPath)) {
+    await snapshotContract(projectRoot, haiveDir, contract);
+    return { contract: contract.name, file: contract.path, changes: [], unchanged: true };
+  }
+  const content = await readFile8(filePath, "utf8");
+  const beforeSnapshot = JSON.parse(await readFile8(lockPath, "utf8"));
+  const afterParsed = parseByFormat(content, contract.format, filePath);
+  const afterSnapshot = {
+    ...beforeSnapshot,
+    hash: sha256(content),
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...afterParsed
+  };
+  const changes = diffSnapshots(beforeSnapshot, afterSnapshot);
+  if (changes.length > 0) {
+    await writeFile6(lockPath, JSON.stringify(afterSnapshot, null, 2) + "\n", "utf8");
+  }
+  return {
+    contract: contract.name,
+    file: contract.path,
+    changes,
+    unchanged: changes.length === 0
+  };
+}
+async function watchContracts(projectRoot, haiveDir, contractFiles) {
+  const results = [];
+  for (const contract of contractFiles) {
+    results.push(await diffContract(projectRoot, haiveDir, contract));
+  }
+  return results.filter((r) => !r.unchanged);
+}
 export {
   AUTOPILOT_DEFAULTS,
   AnchorSchema,
   CHARS_PER_TOKEN,
   CODE_MAP_FILE,
   CONFIG_FILE,
+  CrossRepoProvenanceSchema,
   DECAY_DAYS,
   DEFAULT_AUTO_PROMOTE_RULE,
   DEFAULT_CONFIDENCE_THRESHOLDS,
@@ -971,7 +1555,9 @@ export {
   bumpRead,
   codeMapPath,
   configPath,
+  contractLockPath,
   deriveConfidence,
+  diffContract,
   emptyUsage,
   emptyUsageIndex,
   estimateTokens,
@@ -995,19 +1581,24 @@ export {
   parseMemory,
   pathsOverlap,
   pickSnippetNeedle,
+  pullCrossRepoSources,
   queryCodeMap,
   recordRejection,
   relPathFrom,
   resolveHaivePaths,
+  resolveManifestFiles,
   saveCodeMap,
   saveConfig,
   saveUsageIndex,
   serializeMemory,
+  snapshotContract,
   stripPrivate,
   tokenizeQuery,
+  trackDependencies,
   trackReads,
   truncateToTokens,
   usagePath,
-  verifyAnchor
+  verifyAnchor,
+  watchContracts
 };
 //# sourceMappingURL=index.js.map