@hiveai/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hAIve contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,249 @@
+import { z } from 'zod';
+
+declare const MemoryScopeSchema: z.ZodEnum<["personal", "team", "module"]>;
+declare const MemoryStatusSchema: z.ZodEnum<["draft", "proposed", "validated", "deprecated", "stale"]>;
+declare const MemoryTypeSchema: z.ZodEnum<["convention", "decision", "gotcha", "architecture", "glossary"]>;
+declare const AnchorSchema: z.ZodObject<{
+    commit: z.ZodOptional<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    symbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+    symbols: string[];
+    commit?: string | undefined;
+}, {
+    commit?: string | undefined;
+    paths?: string[] | undefined;
+    symbols?: string[] | undefined;
+}>;
+declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
+    id: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<["personal", "team", "module"]>>;
+    module: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<["convention", "decision", "gotcha", "architecture", "glossary"]>;
+    status: z.ZodDefault<z.ZodEnum<["draft", "proposed", "validated", "deprecated", "stale"]>>;
+    anchor: z.ZodDefault<z.ZodObject<{
+        commit: z.ZodOptional<z.ZodString>;
+        paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        symbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        paths: string[];
+        symbols: string[];
+        commit?: string | undefined;
+    }, {
+        commit?: string | undefined;
+        paths?: string[] | undefined;
+        symbols?: string[] | undefined;
+    }>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    domain: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodPipeline<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodDate]>, string, string | Date>, z.ZodString>;
+    expires_when: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    verified_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    stale_reason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "convention" | "decision" | "gotcha" | "architecture" | "glossary";
+    status: "draft" | "proposed" | "validated" | "deprecated" | "stale";
+    id: string;
+    scope: "personal" | "team" | "module";
+    anchor: {
+        paths: string[];
+        symbols: string[];
+        commit?: string | undefined;
+    };
+    tags: string[];
+    created_at: string;
+    expires_when: string | null;
+    verified_at: string | null;
+    stale_reason: string | null;
+    module?: string | undefined;
+    domain?: string | undefined;
+    author?: string | undefined;
+}, {
+    type: "convention" | "decision" | "gotcha" | "architecture" | "glossary";
+    id: string;
+    created_at: string | Date;
+    module?: string | undefined;
+    status?: "draft" | "proposed" | "validated" | "deprecated" | "stale" | undefined;
+    scope?: "personal" | "team" | "module" | undefined;
+    anchor?: {
+        commit?: string | undefined;
+        paths?: string[] | undefined;
+        symbols?: string[] | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+    domain?: string | undefined;
+    author?: string | undefined;
+    expires_when?: string | null | undefined;
+    verified_at?: string | null | undefined;
+    stale_reason?: string | null | undefined;
+}>, {
+    type: "convention" | "decision" | "gotcha" | "architecture" | "glossary";
+    status: "draft" | "proposed" | "validated" | "deprecated" | "stale";
+    id: string;
+    scope: "personal" | "team" | "module";
+    anchor: {
+        paths: string[];
+        symbols: string[];
+        commit?: string | undefined;
+    };
+    tags: string[];
+    created_at: string;
+    expires_when: string | null;
+    verified_at: string | null;
+    stale_reason: string | null;
+    module?: string | undefined;
+    domain?: string | undefined;
+    author?: string | undefined;
+}, {
+    type: "convention" | "decision" | "gotcha" | "architecture" | "glossary";
+    id: string;
+    created_at: string | Date;
+    module?: string | undefined;
+    status?: "draft" | "proposed" | "validated" | "deprecated" | "stale" | undefined;
+    scope?: "personal" | "team" | "module" | undefined;
+    anchor?: {
+        commit?: string | undefined;
+        paths?: string[] | undefined;
+        symbols?: string[] | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+    domain?: string | undefined;
+    author?: string | undefined;
+    expires_when?: string | null | undefined;
+    verified_at?: string | null | undefined;
+    stale_reason?: string | null | undefined;
+}>;
+
+type MemoryScope = z.infer<typeof MemoryScopeSchema>;
+type MemoryStatus = z.infer<typeof MemoryStatusSchema>;
+type MemoryType = z.infer<typeof MemoryTypeSchema>;
+type Anchor = z.infer<typeof AnchorSchema>;
+type MemoryFrontmatter = z.infer<typeof MemoryFrontmatterSchema>;
+interface Memory {
+    frontmatter: MemoryFrontmatter;
+    body: string;
+}
+
+declare function stripPrivate(body: string): string;
+declare function parseMemory(raw: string): Memory;
+declare function serializeMemory(memory: Memory): string;
+declare function newMemoryId(type: string, slug: string, date?: Date): string;
+declare function buildFrontmatter(input: {
+    type: MemoryFrontmatter["type"];
+    slug: string;
+    scope?: MemoryFrontmatter["scope"];
+    module?: string;
+    tags?: string[];
+    domain?: string;
+    author?: string;
+    paths?: string[];
+    symbols?: string[];
+    commit?: string;
+}): MemoryFrontmatter;
+
+declare const HAIVE_DIR = ".ai";
+declare function findProjectRoot(startDir?: string): string;
+declare const PROJECT_CONTEXT_FILE = "project-context.md";
+declare const MEMORIES_DIR = "memories";
+interface HaivePaths {
+    root: string;
+    haiveDir: string;
+    projectContext: string;
+    memoriesDir: string;
+    personalDir: string;
+    teamDir: string;
+    moduleDir: string;
+    modulesContextDir: string;
+}
+declare function resolveHaivePaths(projectRoot: string): HaivePaths;
+declare function memoryFilePath(paths: HaivePaths, scope: "personal" | "team" | "module", id: string, module?: string): string;
+
+interface LoadedMemory {
+    memory: Memory;
+    filePath: string;
+}
+declare function listMarkdownFilesRecursive(dir: string): Promise<string[]>;
+declare function loadMemory(filePath: string): Promise<LoadedMemory>;
+declare function loadMemoriesFromDir(dir: string): Promise<LoadedMemory[]>;
+
+declare function tokenizeQuery(query: string): string[];
+declare function literalMatchesAllTokens(memory: Memory, tokens: string[]): boolean;
+declare function pickSnippetNeedle(query: string): string;
+declare function extractSnippet(body: string, needle: string, radius?: number): string;
+
+interface VerifyResult {
+    stale: boolean;
+    reason: string | null;
+    checkedPaths: string[];
+    checkedSymbols: string[];
+}
+interface VerifyOptions {
+    /** Project root used to resolve relative anchor paths. */
+    projectRoot: string;
+}
+/**
+ * Verify that a memory's anchor still matches the current code.
+ * - Every anchor.paths entry must exist on disk
+ * - Every anchor.symbols entry must appear at least once across the anchor.paths
+ *   files (or any tracked file if no paths are recorded)
+ *
+ * Anchorless memories (no paths and no symbols) are always considered fresh —
+ * staleness only applies to memories that opted into anchoring.
+ */
+declare function verifyAnchor(memory: Memory, options: VerifyOptions): Promise<VerifyResult>;
+
+interface MemoryUsage {
+    read_count: number;
+    last_read_at: string | null;
+    rejected_count: number;
+    last_rejected_at: string | null;
+    rejection_reason: string | null;
+}
+interface UsageIndex {
+    version: 1;
+    updated_at: string;
+    by_id: Record<string, MemoryUsage>;
+}
+declare const USAGE_FILE = "usage.json";
+declare function emptyUsage(): MemoryUsage;
+declare function emptyUsageIndex(): UsageIndex;
+declare function usagePath(paths: HaivePaths): string;
+declare function loadUsageIndex(paths: HaivePaths): Promise<UsageIndex>;
+declare function saveUsageIndex(paths: HaivePaths, index: UsageIndex): Promise<void>;
+declare function getUsage(index: UsageIndex, id: string): MemoryUsage;
+declare function bumpRead(index: UsageIndex, ids: string[]): UsageIndex;
+declare function recordRejection(index: UsageIndex, id: string, reason: string | null): UsageIndex;
+declare function trackReads(paths: HaivePaths, ids: string[]): Promise<UsageIndex>;
+
+type ConfidenceLevel = "unverified" | "low" | "trusted" | "authoritative" | "stale";
+interface ConfidenceThresholds {
+    trustedReads: number;
+    authoritativeReads: number;
+}
+declare const DEFAULT_CONFIDENCE_THRESHOLDS: ConfidenceThresholds;
+declare function deriveConfidence(fm: MemoryFrontmatter, usage: MemoryUsage, thresholds?: ConfidenceThresholds): ConfidenceLevel;
+interface AutoPromoteRule {
+    /** Minimum read_count to promote proposed → validated. */
+    minReads: number;
+    /** Maximum rejected_count tolerated (memories with more rejections never auto-promote). */
+    maxRejections: number;
+}
+declare const DEFAULT_AUTO_PROMOTE_RULE: AutoPromoteRule;
+declare function isAutoPromoteEligible(fm: MemoryFrontmatter, usage: MemoryUsage, rule?: AutoPromoteRule): boolean;
+
+/**
+ * Best-effort inference: given a list of file paths, infer module names from
+ * conventional layouts (packages/X/, apps/X/, modules/X/, src/X/).
+ */
+declare function inferModulesFromPaths(filePaths: string[]): string[];
+/**
+ * Path overlap: returns true if `a` and `b` refer to the same path or one is a
+ * parent of the other. Both inputs are treated as POSIX-style relative paths.
+ */
+declare function pathsOverlap(a: string, b: string): boolean;
+declare function memoryMatchesAnchorPaths(memory: LoadedMemory["memory"], inputPaths: string[]): boolean;
+declare function relPathFrom(root: string, abs: string): string;
+
+export { type Anchor, AnchorSchema, type AutoPromoteRule, type ConfidenceLevel, type ConfidenceThresholds, DEFAULT_AUTO_PROMOTE_RULE, DEFAULT_CONFIDENCE_THRESHOLDS, HAIVE_DIR, type HaivePaths, type LoadedMemory, MEMORIES_DIR, type Memory, type MemoryFrontmatter, MemoryFrontmatterSchema, type MemoryScope, MemoryScopeSchema, type MemoryStatus, MemoryStatusSchema, type MemoryType, MemoryTypeSchema, type MemoryUsage, PROJECT_CONTEXT_FILE, USAGE_FILE, type UsageIndex, type VerifyOptions, type VerifyResult, buildFrontmatter, bumpRead, deriveConfidence, emptyUsage, emptyUsageIndex, extractSnippet, findProjectRoot, getUsage, inferModulesFromPaths, isAutoPromoteEligible, listMarkdownFilesRecursive, literalMatchesAllTokens, loadMemoriesFromDir, loadMemory, loadUsageIndex, memoryFilePath, memoryMatchesAnchorPaths, newMemoryId, parseMemory, pathsOverlap, pickSnippetNeedle, recordRejection, relPathFrom, resolveHaivePaths, saveUsageIndex, serializeMemory, stripPrivate, tokenizeQuery, trackReads, usagePath, verifyAnchor };

package/dist/index.js

@@ -0,0 +1,462 @@
+// src/schema.ts
+import { z } from "zod";
+var MemoryScopeSchema = z.enum(["personal", "team", "module"]);
+var MemoryStatusSchema = z.enum([
+  "draft",
+  "proposed",
+  "validated",
+  "deprecated",
+  "stale"
+]);
+var MemoryTypeSchema = z.enum([
+  "convention",
+  "decision",
+  "gotcha",
+  "architecture",
+  "glossary"
+]);
+var AnchorSchema = z.object({
+  commit: z.string().optional(),
+  paths: z.array(z.string()).default([]),
+  symbols: z.array(z.string()).default([])
+});
+var IsoDateString = z.union([z.string(), z.date()]).transform((v) => v instanceof Date ? v.toISOString() : v).pipe(z.string().datetime());
+var MemoryFrontmatterSchema = z.object({
+  id: z.string().min(1),
+  scope: MemoryScopeSchema.default("personal"),
+  module: z.string().optional(),
+  type: MemoryTypeSchema,
+  status: MemoryStatusSchema.default("draft"),
+  anchor: AnchorSchema.default({ paths: [], symbols: [] }),
+  tags: z.array(z.string()).default([]),
+  domain: z.string().optional(),
+  author: z.string().optional(),
+  created_at: IsoDateString,
+  expires_when: z.string().nullable().default(null),
+  verified_at: z.string().nullable().default(null),
+  stale_reason: z.string().nullable().default(null)
+}).refine(
+  (data) => data.scope !== "module" || !!data.module,
+  { message: "module name is required when scope is 'module'", path: ["module"] }
+);
+
+// src/parser.ts
+import matter from "gray-matter";
+var PRIVATE_BLOCK_RE = /<private>[\s\S]*?<\/private>/g;
+function stripPrivate(body) {
+  return body.replace(PRIVATE_BLOCK_RE, "").trimEnd();
+}
+function parseMemory(raw) {
+  const parsed = matter(raw);
+  const frontmatter = MemoryFrontmatterSchema.parse(parsed.data);
+  return {
+    frontmatter,
+    body: stripPrivate(parsed.content.trim())
+  };
+}
+function stripUndefined(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => stripUndefined(v));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === void 0) continue;
+      out[k] = stripUndefined(v);
+    }
+    return out;
+  }
+  return value;
+}
+function serializeMemory(memory) {
+  const clean = stripUndefined(memory.frontmatter);
+  return matter.stringify(memory.body, clean);
+}
+function newMemoryId(type, slug, date = /* @__PURE__ */ new Date()) {
+  const isoDate = date.toISOString().slice(0, 10);
+  const safeSlug = slug.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+  return `${isoDate}-${type}-${safeSlug}`;
+}
+function buildFrontmatter(input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = newMemoryId(input.type, input.slug, now);
+  return MemoryFrontmatterSchema.parse({
+    id,
+    scope: input.scope ?? "personal",
+    module: input.module,
+    type: input.type,
+    status: "draft",
+    anchor: {
+      commit: input.commit,
+      paths: input.paths ?? [],
+      symbols: input.symbols ?? []
+    },
+    tags: input.tags ?? [],
+    domain: input.domain,
+    author: input.author,
+    created_at: now.toISOString(),
+    expires_when: null
+  });
+}
+
+// src/paths.ts
+import { existsSync } from "fs";
+import path from "path";
+var HAIVE_DIR = ".ai";
+var ROOT_MARKERS = [".ai", ".git", "package.json"];
+function findProjectRoot(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+  const fsRoot = path.parse(current).root;
+  while (current !== fsRoot) {
+    for (const marker of ROOT_MARKERS) {
+      if (existsSync(path.join(current, marker))) return current;
+    }
+    current = path.dirname(current);
+  }
+  return path.resolve(startDir);
+}
+var PROJECT_CONTEXT_FILE = "project-context.md";
+var MEMORIES_DIR = "memories";
+function resolveHaivePaths(projectRoot) {
+  const haiveDir = path.join(projectRoot, HAIVE_DIR);
+  const memoriesDir = path.join(haiveDir, MEMORIES_DIR);
+  return {
+    root: projectRoot,
+    haiveDir,
+    projectContext: path.join(haiveDir, PROJECT_CONTEXT_FILE),
+    memoriesDir,
+    personalDir: path.join(memoriesDir, "personal"),
+    teamDir: path.join(memoriesDir, "team"),
+    moduleDir: path.join(memoriesDir, "module"),
+    modulesContextDir: path.join(haiveDir, "modules")
+  };
+}
+function memoryFilePath(paths, scope, id, module) {
+  const base = scope === "personal" ? paths.personalDir : scope === "team" ? paths.teamDir : path.join(paths.moduleDir, module ?? "_unscoped");
+  return path.join(base, `${id}.md`);
+}
+
+// src/loader.ts
+import { readdir, readFile } from "fs/promises";
+import path2 from "path";
+async function listMarkdownFilesRecursive(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await listMarkdownFilesRecursive(full));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+async function loadMemory(filePath) {
+  const raw = await readFile(filePath, "utf8");
+  return { memory: parseMemory(raw), filePath };
+}
+async function loadMemoriesFromDir(dir) {
+  const files = await listMarkdownFilesRecursive(dir);
+  const out = [];
+  for (const file of files) {
+    try {
+      out.push(await loadMemory(file));
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/search.ts
+function tokenizeQuery(query) {
+  return query.toLowerCase().split(/\s+/).map((t) => t.trim()).filter(Boolean);
+}
+function literalMatchesAllTokens(memory, tokens) {
+  if (tokens.length === 0) return true;
+  const fm = memory.frontmatter;
+  const idLower = fm.id.toLowerCase();
+  const tagsLower = fm.tags.map((t) => t.toLowerCase());
+  const bodyLower = memory.body.toLowerCase();
+  return tokens.every((rawTok) => {
+    const tok = rawTok.toLowerCase();
+    return idLower.includes(tok) || tagsLower.some((t) => t.includes(tok)) || bodyLower.includes(tok);
+  });
+}
+function pickSnippetNeedle(query) {
+  const tokens = tokenizeQuery(query);
+  if (tokens.length === 0) return query.toLowerCase();
+  return [...tokens].sort((a, b) => b.length - a.length)[0];
+}
+function extractSnippet(body, needle, radius = 40) {
+  const lower = body.toLowerCase();
+  const idx = needle ? lower.indexOf(needle) : -1;
+  if (idx < 0) {
+    return body.slice(0, radius * 3).replace(/\s+/g, " ").trim();
+  }
+  const start = Math.max(0, idx - radius);
+  const end = Math.min(body.length, idx + needle.length + radius);
+  const snippet = body.slice(start, end).replace(/\s+/g, " ").trim();
+  return (start > 0 ? "\u2026" : "") + snippet + (end < body.length ? "\u2026" : "");
+}
+
+// src/verifier.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
+async function verifyAnchor(memory, options) {
+  const anchor = memory.frontmatter.anchor;
+  const checkedPaths = anchor.paths;
+  const checkedSymbols = anchor.symbols;
+  if (checkedPaths.length === 0 && checkedSymbols.length === 0) {
+    return { stale: false, reason: null, checkedPaths, checkedSymbols };
+  }
+  const missingPaths = [];
+  const existingAbsPaths = [];
+  for (const rel of checkedPaths) {
+    const abs = path3.isAbsolute(rel) ? rel : path3.join(options.projectRoot, rel);
+    if (existsSync2(abs)) {
+      existingAbsPaths.push(abs);
+    } else {
+      missingPaths.push(rel);
+    }
+  }
+  if (missingPaths.length > 0) {
+    return {
+      stale: true,
+      reason: `anchor path(s) no longer exist: ${missingPaths.join(", ")}`,
+      checkedPaths,
+      checkedSymbols
+    };
+  }
+  if (checkedSymbols.length > 0) {
+    if (existingAbsPaths.length === 0) {
+      return {
+        stale: true,
+        reason: `cannot verify symbols (${checkedSymbols.join(", ")}): no anchor paths recorded`,
+        checkedPaths,
+        checkedSymbols
+      };
+    }
+    const missingSymbols = [];
+    for (const sym of checkedSymbols) {
+      let found = false;
+      for (const file of existingAbsPaths) {
+        try {
+          const contents = await readFile2(file, "utf8");
+          if (contents.includes(sym)) {
+            found = true;
+            break;
+          }
+        } catch {
+        }
+      }
+      if (!found) missingSymbols.push(sym);
+    }
+    if (missingSymbols.length > 0) {
+      return {
+        stale: true,
+        reason: `anchor symbol(s) not found in any anchor path: ${missingSymbols.join(", ")}`,
+        checkedPaths,
+        checkedSymbols
+      };
+    }
+  }
+  return { stale: false, reason: null, checkedPaths, checkedSymbols };
+}
+
+// src/usage.ts
+import { mkdir, readFile as readFile3, writeFile } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import path4 from "path";
+var USAGE_FILE = "usage.json";
+function emptyUsage() {
+  return {
+    read_count: 0,
+    last_read_at: null,
+    rejected_count: 0,
+    last_rejected_at: null,
+    rejection_reason: null
+  };
+}
+function emptyUsageIndex() {
+  return {
+    version: 1,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    by_id: {}
+  };
+}
+function usagePath(paths) {
+  return path4.join(paths.haiveDir, ".cache", USAGE_FILE);
+}
+async function loadUsageIndex(paths) {
+  const file = usagePath(paths);
+  if (!existsSync3(file)) return emptyUsageIndex();
+  const raw = await readFile3(file, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1) return emptyUsageIndex();
+    return parsed;
+  } catch {
+    return emptyUsageIndex();
+  }
+}
+async function saveUsageIndex(paths, index) {
+  const file = usagePath(paths);
+  await mkdir(path4.dirname(file), { recursive: true });
+  index.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(file, JSON.stringify(index, null, 2), "utf8");
+}
+function getUsage(index, id) {
+  return index.by_id[id] ?? emptyUsage();
+}
+function bumpRead(index, ids) {
+  if (ids.length === 0) return index;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const id of ids) {
+    const current = index.by_id[id] ?? emptyUsage();
+    index.by_id[id] = {
+      ...current,
+      read_count: current.read_count + 1,
+      last_read_at: now
+    };
+  }
+  return index;
+}
+function recordRejection(index, id, reason) {
+  const current = index.by_id[id] ?? emptyUsage();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  index.by_id[id] = {
+    ...current,
+    rejected_count: current.rejected_count + 1,
+    last_rejected_at: now,
+    rejection_reason: reason
+  };
+  return index;
+}
+async function trackReads(paths, ids) {
+  if (ids.length === 0) {
+    return await loadUsageIndex(paths);
+  }
+  const index = await loadUsageIndex(paths);
+  bumpRead(index, ids);
+  await saveUsageIndex(paths, index);
+  return index;
+}
+
+// src/confidence.ts
+var DEFAULT_CONFIDENCE_THRESHOLDS = {
+  trustedReads: 3,
+  authoritativeReads: 10
+};
+function deriveConfidence(fm, usage, thresholds = DEFAULT_CONFIDENCE_THRESHOLDS) {
+  if (fm.status === "stale" || fm.status === "deprecated") return "stale";
+  if (fm.status === "validated") {
+    return usage.read_count >= thresholds.authoritativeReads ? "authoritative" : "trusted";
+  }
+  if (fm.status === "proposed") {
+    return usage.read_count >= thresholds.trustedReads ? "trusted" : "low";
+  }
+  return "unverified";
+}
+var DEFAULT_AUTO_PROMOTE_RULE = {
+  minReads: 5,
+  maxRejections: 0
+};
+function isAutoPromoteEligible(fm, usage, rule = DEFAULT_AUTO_PROMOTE_RULE) {
+  if (fm.status !== "proposed") return false;
+  if (usage.rejected_count > rule.maxRejections) return false;
+  return usage.read_count >= rule.minReads;
+}
+
+// src/relevance.ts
+import path5 from "path";
+var MODULE_PATTERNS = [
+  /^packages\/([^/]+)\//,
+  /^apps\/([^/]+)\//,
+  /^modules\/([^/]+)\//,
+  /^src\/([^/]+)\//
+];
+function inferModulesFromPaths(filePaths) {
+  const out = /* @__PURE__ */ new Set();
+  for (const p of filePaths) {
+    const norm = normalize(p);
+    for (const re of MODULE_PATTERNS) {
+      const m = norm.match(re);
+      if (m && m[1]) out.add(m[1]);
+    }
+  }
+  return [...out].sort();
+}
+function pathsOverlap(a, b) {
+  const na = normalize(a);
+  const nb = normalize(b);
+  if (na === nb) return true;
+  return na.startsWith(nb + "/") || nb.startsWith(na + "/");
+}
+function memoryMatchesAnchorPaths(memory, inputPaths) {
+  const anchorPaths = memory.frontmatter.anchor.paths;
+  if (anchorPaths.length === 0) return false;
+  for (const ap of anchorPaths) {
+    for (const ip of inputPaths) {
+      if (pathsOverlap(ap, ip)) return true;
+    }
+  }
+  return false;
+}
+function normalize(p) {
+  return p.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+function relPathFrom(root, abs) {
+  return path5.relative(root, abs).replace(/\\/g, "/");
+}
+export {
+  AnchorSchema,
+  DEFAULT_AUTO_PROMOTE_RULE,
+  DEFAULT_CONFIDENCE_THRESHOLDS,
+  HAIVE_DIR,
+  MEMORIES_DIR,
+  MemoryFrontmatterSchema,
+  MemoryScopeSchema,
+  MemoryStatusSchema,
+  MemoryTypeSchema,
+  PROJECT_CONTEXT_FILE,
+  USAGE_FILE,
+  buildFrontmatter,
+  bumpRead,
+  deriveConfidence,
+  emptyUsage,
+  emptyUsageIndex,
+  extractSnippet,
+  findProjectRoot,
+  getUsage,
+  inferModulesFromPaths,
+  isAutoPromoteEligible,
+  listMarkdownFilesRecursive,
+  literalMatchesAllTokens,
+  loadMemoriesFromDir,
+  loadMemory,
+  loadUsageIndex,
+  memoryFilePath,
+  memoryMatchesAnchorPaths,
+  newMemoryId,
+  parseMemory,
+  pathsOverlap,
+  pickSnippetNeedle,
+  recordRejection,
+  relPathFrom,
+  resolveHaivePaths,
+  saveUsageIndex,
+  serializeMemory,
+  stripPrivate,
+  tokenizeQuery,
+  trackReads,
+  usagePath,
+  verifyAnchor
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts","../src/parser.ts","../src/paths.ts","../src/loader.ts","../src/search.ts","../src/verifier.ts","../src/usage.ts","../src/confidence.ts","../src/relevance.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const MemoryScopeSchema = z.enum([\"personal\", \"team\", \"module\"]);\n\nexport const MemoryStatusSchema = z.enum([\n  \"draft\",\n  \"proposed\",\n  \"validated\",\n  \"deprecated\",\n  \"stale\",\n]);\n\nexport const MemoryTypeSchema = z.enum([\n  \"convention\",\n  \"decision\",\n  \"gotcha\",\n  \"architecture\",\n  \"glossary\",\n]);\n\nexport const AnchorSchema = z.object({\n  commit: z.string().optional(),\n  paths: z.array(z.string()).default([]),\n  symbols: z.array(z.string()).default([]),\n});\n\nconst IsoDateString = z\n  .union([z.string(), z.date()])\n  .transform((v) => (v instanceof Date ? v.toISOString() : v))\n  .pipe(z.string().datetime());\n\nexport const MemoryFrontmatterSchema = z\n  .object({\n    id: z.string().min(1),\n    scope: MemoryScopeSchema.default(\"personal\"),\n    module: z.string().optional(),\n    type: MemoryTypeSchema,\n    status: MemoryStatusSchema.default(\"draft\"),\n    anchor: AnchorSchema.default({ paths: [], symbols: [] }),\n    tags: z.array(z.string()).default([]),\n    domain: z.string().optional(),\n    author: z.string().optional(),\n    created_at: IsoDateString,\n    expires_when: z.string().nullable().default(null),\n    verified_at: z.string().nullable().default(null),\n    stale_reason: z.string().nullable().default(null),\n  })\n  .refine(\n    (data) => data.scope !== \"module\" || !!data.module,\n    { message: \"module name is required when scope is 'module'\", path: [\"module\"] },\n  );\n","import matter from \"gray-matter\";\nimport { MemoryFrontmatterSchema } from \"./schema.js\";\nimport type { Memory, MemoryFrontmatter } from \"./types.js\";\n\nconst PRIVATE_BLOCK_RE = /<private>[\\s\\S]*?<\\/private>/g;\n\nexport function stripPrivate(body: string): string {\n  return body.replace(PRIVATE_BLOCK_RE, \"\").trimEnd();\n}\n\nexport function parseMemory(raw: string): Memory {\n  const parsed = matter(raw);\n  const frontmatter = MemoryFrontmatterSchema.parse(parsed.data);\n  return {\n    frontmatter,\n    body: stripPrivate(parsed.content.trim()),\n  };\n}\n\nfunction stripUndefined<T>(value: T): T {\n  if (Array.isArray(value)) {\n    return value.map((v) => stripUndefined(v)) as unknown as T;\n  }\n  if (value && typeof value === \"object\") {\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n      if (v === undefined) continue;\n      out[k] = stripUndefined(v);\n    }\n    return out as T;\n  }\n  return value;\n}\n\nexport function serializeMemory(memory: Memory): string {\n  const clean = stripUndefined(memory.frontmatter) as Record<string, unknown>;\n  return matter.stringify(memory.body, clean);\n}\n\nexport function newMemoryId(type: string, slug: string, date = new Date()): string {\n  const isoDate = date.toISOString().slice(0, 10);\n  const safeSlug = slug\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-|-$/g, \"\")\n    .slice(0, 60);\n  return `${isoDate}-${type}-${safeSlug}`;\n}\n\nexport function buildFrontmatter(input: {\n  type: MemoryFrontmatter[\"type\"];\n  slug: string;\n  scope?: MemoryFrontmatter[\"scope\"];\n  module?: string;\n  tags?: string[];\n  domain?: string;\n  author?: string;\n  paths?: string[];\n  symbols?: string[];\n  commit?: string;\n}): MemoryFrontmatter {\n  const now = new Date();\n  const id = newMemoryId(input.type, input.slug, now);\n  return MemoryFrontmatterSchema.parse({\n    id,\n    scope: input.scope ?? \"personal\",\n    module: input.module,\n    type: input.type,\n    status: \"draft\",\n    anchor: {\n      commit: input.commit,\n      paths: input.paths ?? [],\n      symbols: input.symbols ?? [],\n    },\n    tags: input.tags ?? [],\n    domain: input.domain,\n    author: input.author,\n    created_at: now.toISOString(),\n    expires_when: null,\n  });\n}\n","import { existsSync } from \"node:fs\";\nimport path from \"node:path\";\n\nexport const HAIVE_DIR = \".ai\";\n\nconst ROOT_MARKERS = [\".ai\", \".git\", \"package.json\"];\n\nexport function findProjectRoot(startDir: string = process.cwd()): string {\n  let current = path.resolve(startDir);\n  const fsRoot = path.parse(current).root;\n  while (current !== fsRoot) {\n    for (const marker of ROOT_MARKERS) {\n      if (existsSync(path.join(current, marker))) return current;\n    }\n    current = path.dirname(current);\n  }\n  return path.resolve(startDir);\n}\n\nexport const PROJECT_CONTEXT_FILE = \"project-context.md\";\nexport const MEMORIES_DIR = \"memories\";\n\nexport interface HaivePaths {\n  root: string;\n  haiveDir: string;\n  projectContext: string;\n  memoriesDir: string;\n  personalDir: string;\n  teamDir: string;\n  moduleDir: string;\n  modulesContextDir: string;\n}\n\nexport function resolveHaivePaths(projectRoot: string): HaivePaths {\n  const haiveDir = path.join(projectRoot, HAIVE_DIR);\n  const memoriesDir = path.join(haiveDir, MEMORIES_DIR);\n  return {\n    root: projectRoot,\n    haiveDir,\n    projectContext: path.join(haiveDir, PROJECT_CONTEXT_FILE),\n    memoriesDir,\n    personalDir: path.join(memoriesDir, \"personal\"),\n    teamDir: path.join(memoriesDir, \"team\"),\n    moduleDir: path.join(memoriesDir, \"module\"),\n    modulesContextDir: path.join(haiveDir, \"modules\"),\n  };\n}\n\nexport function memoryFilePath(\n  paths: HaivePaths,\n  scope: \"personal\" | \"team\" | \"module\",\n  id: string,\n  module?: string,\n): string {\n  const base =\n    scope === \"personal\"\n      ? paths.personalDir\n      : scope === \"team\"\n        ? paths.teamDir\n        : path.join(paths.moduleDir, module ?? \"_unscoped\");\n  return path.join(base, `${id}.md`);\n}\n","import { readdir, readFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { parseMemory } from \"./parser.js\";\nimport type { Memory } from \"./types.js\";\n\nexport interface LoadedMemory {\n  memory: Memory;\n  filePath: string;\n}\n\nexport async function listMarkdownFilesRecursive(dir: string): Promise<string[]> {\n  const out: string[] = [];\n  let entries;\n  try {\n    entries = await readdir(dir, { withFileTypes: true });\n  } catch {\n    return out;\n  }\n  for (const entry of entries) {\n    const full = path.join(dir, entry.name);\n    if (entry.isDirectory()) {\n      out.push(...(await listMarkdownFilesRecursive(full)));\n    } else if (entry.isFile() && entry.name.endsWith(\".md\")) {\n      out.push(full);\n    }\n  }\n  return out;\n}\n\nexport async function loadMemory(filePath: string): Promise<LoadedMemory> {\n  const raw = await readFile(filePath, \"utf8\");\n  return { memory: parseMemory(raw), filePath };\n}\n\nexport async function loadMemoriesFromDir(dir: string): Promise<LoadedMemory[]> {\n  const files = await listMarkdownFilesRecursive(dir);\n  const out: LoadedMemory[] = [];\n  for (const file of files) {\n    try {\n      out.push(await loadMemory(file));\n    } catch {\n      // Skip unparseable files in v0.1; future: surface a warning channel.\n    }\n  }\n  return out;\n}\n","import type { Memory } from \"./types.js\";\n\nexport function tokenizeQuery(query: string): string[] {\n  return query\n    .toLowerCase()\n    .split(/\\s+/)\n    .map((t) => t.trim())\n    .filter(Boolean);\n}\n\nexport function literalMatchesAllTokens(memory: Memory, tokens: string[]): boolean {\n  if (tokens.length === 0) return true;\n  const fm = memory.frontmatter;\n  const idLower = fm.id.toLowerCase();\n  const tagsLower = fm.tags.map((t) => t.toLowerCase());\n  const bodyLower = memory.body.toLowerCase();\n  return tokens.every((rawTok) => {\n    const tok = rawTok.toLowerCase();\n    return (\n      idLower.includes(tok) ||\n      tagsLower.some((t) => t.includes(tok)) ||\n      bodyLower.includes(tok)\n    );\n  });\n}\n\nexport function pickSnippetNeedle(query: string): string {\n  const tokens = tokenizeQuery(query);\n  if (tokens.length === 0) return query.toLowerCase();\n  return [...tokens].sort((a, b) => b.length - a.length)[0]!;\n}\n\nexport function extractSnippet(body: string, needle: string, radius = 40): string {\n  const lower = body.toLowerCase();\n  const idx = needle ? lower.indexOf(needle) : -1;\n  if (idx < 0) {\n    return body.slice(0, radius * 3).replace(/\\s+/g, \" \").trim();\n  }\n  const start = Math.max(0, idx - radius);\n  const end = Math.min(body.length, idx + needle.length + radius);\n  const snippet = body.slice(start, end).replace(/\\s+/g, \" \").trim();\n  return (start > 0 ? \"…\" : \"\") + snippet + (end < body.length ? \"…\" : \"\");\n}\n","import { readFile } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport type { Memory } from \"./types.js\";\n\nexport interface VerifyResult {\n  stale: boolean;\n  reason: string | null;\n  checkedPaths: string[];\n  checkedSymbols: string[];\n}\n\nexport interface VerifyOptions {\n  /** Project root used to resolve relative anchor paths. */\n  projectRoot: string;\n}\n\n/**\n * Verify that a memory's anchor still matches the current code.\n * - Every anchor.paths entry must exist on disk\n * - Every anchor.symbols entry must appear at least once across the anchor.paths\n *   files (or any tracked file if no paths are recorded)\n *\n * Anchorless memories (no paths and no symbols) are always considered fresh —\n * staleness only applies to memories that opted into anchoring.\n */\nexport async function verifyAnchor(\n  memory: Memory,\n  options: VerifyOptions,\n): Promise<VerifyResult> {\n  const anchor = memory.frontmatter.anchor;\n  const checkedPaths = anchor.paths;\n  const checkedSymbols = anchor.symbols;\n\n  if (checkedPaths.length === 0 && checkedSymbols.length === 0) {\n    return { stale: false, reason: null, checkedPaths, checkedSymbols };\n  }\n\n  const missingPaths: string[] = [];\n  const existingAbsPaths: string[] = [];\n  for (const rel of checkedPaths) {\n    const abs = path.isAbsolute(rel) ? rel : path.join(options.projectRoot, rel);\n    if (existsSync(abs)) {\n      existingAbsPaths.push(abs);\n    } else {\n      missingPaths.push(rel);\n    }\n  }\n\n  if (missingPaths.length > 0) {\n    return {\n      stale: true,\n      reason: `anchor path(s) no longer exist: ${missingPaths.join(\", \")}`,\n      checkedPaths,\n      checkedSymbols,\n    };\n  }\n\n  if (checkedSymbols.length > 0) {\n    if (existingAbsPaths.length === 0) {\n      return {\n        stale: true,\n        reason: `cannot verify symbols (${checkedSymbols.join(\", \")}): no anchor paths recorded`,\n        checkedPaths,\n        checkedSymbols,\n      };\n    }\n    const missingSymbols: string[] = [];\n    for (const sym of checkedSymbols) {\n      let found = false;\n      for (const file of existingAbsPaths) {\n        try {\n          const contents = await readFile(file, \"utf8\");\n          if (contents.includes(sym)) {\n            found = true;\n            break;\n          }\n        } catch {\n          // unreadable file; treat as not finding the symbol here\n        }\n      }\n      if (!found) missingSymbols.push(sym);\n    }\n    if (missingSymbols.length > 0) {\n      return {\n        stale: true,\n        reason: `anchor symbol(s) not found in any anchor path: ${missingSymbols.join(\", \")}`,\n        checkedPaths,\n        checkedSymbols,\n      };\n    }\n  }\n\n  return { stale: false, reason: null, checkedPaths, checkedSymbols };\n}\n","import { mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport type { HaivePaths } from \"./paths.js\";\n\nexport interface MemoryUsage {\n  read_count: number;\n  last_read_at: string | null;\n  rejected_count: number;\n  last_rejected_at: string | null;\n  rejection_reason: string | null;\n}\n\nexport interface UsageIndex {\n  version: 1;\n  updated_at: string;\n  by_id: Record<string, MemoryUsage>;\n}\n\nexport const USAGE_FILE = \"usage.json\";\n\nexport function emptyUsage(): MemoryUsage {\n  return {\n    read_count: 0,\n    last_read_at: null,\n    rejected_count: 0,\n    last_rejected_at: null,\n    rejection_reason: null,\n  };\n}\n\nexport function emptyUsageIndex(): UsageIndex {\n  return {\n    version: 1,\n    updated_at: new Date().toISOString(),\n    by_id: {},\n  };\n}\n\nexport function usagePath(paths: HaivePaths): string {\n  return path.join(paths.haiveDir, \".cache\", USAGE_FILE);\n}\n\nexport async function loadUsageIndex(paths: HaivePaths): Promise<UsageIndex> {\n  const file = usagePath(paths);\n  if (!existsSync(file)) return emptyUsageIndex();\n  const raw = await readFile(file, \"utf8\");\n  try {\n    const parsed = JSON.parse(raw) as UsageIndex;\n    if (parsed.version !== 1) return emptyUsageIndex();\n    return parsed;\n  } catch {\n    return emptyUsageIndex();\n  }\n}\n\nexport async function saveUsageIndex(paths: HaivePaths, index: UsageIndex): Promise<void> {\n  const file = usagePath(paths);\n  await mkdir(path.dirname(file), { recursive: true });\n  index.updated_at = new Date().toISOString();\n  await writeFile(file, JSON.stringify(index, null, 2), \"utf8\");\n}\n\nexport function getUsage(index: UsageIndex, id: string): MemoryUsage {\n  return index.by_id[id] ?? emptyUsage();\n}\n\nexport function bumpRead(index: UsageIndex, ids: string[]): UsageIndex {\n  if (ids.length === 0) return index;\n  const now = new Date().toISOString();\n  for (const id of ids) {\n    const current = index.by_id[id] ?? emptyUsage();\n    index.by_id[id] = {\n      ...current,\n      read_count: current.read_count + 1,\n      last_read_at: now,\n    };\n  }\n  return index;\n}\n\nexport function recordRejection(\n  index: UsageIndex,\n  id: string,\n  reason: string | null,\n): UsageIndex {\n  const current = index.by_id[id] ?? emptyUsage();\n  const now = new Date().toISOString();\n  index.by_id[id] = {\n    ...current,\n    rejected_count: current.rejected_count + 1,\n    last_rejected_at: now,\n    rejection_reason: reason,\n  };\n  return index;\n}\n\nexport async function trackReads(\n  paths: HaivePaths,\n  ids: string[],\n): Promise<UsageIndex> {\n  if (ids.length === 0) {\n    return await loadUsageIndex(paths);\n  }\n  const index = await loadUsageIndex(paths);\n  bumpRead(index, ids);\n  await saveUsageIndex(paths, index);\n  return index;\n}\n","import type { MemoryFrontmatter } from \"./types.js\";\nimport type { MemoryUsage } from \"./usage.js\";\n\nexport type ConfidenceLevel =\n  | \"unverified\"\n  | \"low\"\n  | \"trusted\"\n  | \"authoritative\"\n  | \"stale\";\n\nexport interface ConfidenceThresholds {\n  trustedReads: number;\n  authoritativeReads: number;\n}\n\nexport const DEFAULT_CONFIDENCE_THRESHOLDS: ConfidenceThresholds = {\n  trustedReads: 3,\n  authoritativeReads: 10,\n};\n\nexport function deriveConfidence(\n  fm: MemoryFrontmatter,\n  usage: MemoryUsage,\n  thresholds: ConfidenceThresholds = DEFAULT_CONFIDENCE_THRESHOLDS,\n): ConfidenceLevel {\n  if (fm.status === \"stale\" || fm.status === \"deprecated\") return \"stale\";\n  if (fm.status === \"validated\") {\n    return usage.read_count >= thresholds.authoritativeReads\n      ? \"authoritative\"\n      : \"trusted\";\n  }\n  if (fm.status === \"proposed\") {\n    return usage.read_count >= thresholds.trustedReads ? \"trusted\" : \"low\";\n  }\n  // draft\n  return \"unverified\";\n}\n\nexport interface AutoPromoteRule {\n  /** Minimum read_count to promote proposed → validated. */\n  minReads: number;\n  /** Maximum rejected_count tolerated (memories with more rejections never auto-promote). */\n  maxRejections: number;\n}\n\nexport const DEFAULT_AUTO_PROMOTE_RULE: AutoPromoteRule = {\n  minReads: 5,\n  maxRejections: 0,\n};\n\nexport function isAutoPromoteEligible(\n  fm: MemoryFrontmatter,\n  usage: MemoryUsage,\n  rule: AutoPromoteRule = DEFAULT_AUTO_PROMOTE_RULE,\n): boolean {\n  if (fm.status !== \"proposed\") return false;\n  if (usage.rejected_count > rule.maxRejections) return false;\n  return usage.read_count >= rule.minReads;\n}\n","import path from \"node:path\";\nimport type { LoadedMemory } from \"./loader.js\";\n\nconst MODULE_PATTERNS = [\n  /^packages\\/([^/]+)\\//,\n  /^apps\\/([^/]+)\\//,\n  /^modules\\/([^/]+)\\//,\n  /^src\\/([^/]+)\\//,\n];\n\n/**\n * Best-effort inference: given a list of file paths, infer module names from\n * conventional layouts (packages/X/, apps/X/, modules/X/, src/X/).\n */\nexport function inferModulesFromPaths(filePaths: string[]): string[] {\n  const out = new Set<string>();\n  for (const p of filePaths) {\n    const norm = normalize(p);\n    for (const re of MODULE_PATTERNS) {\n      const m = norm.match(re);\n      if (m && m[1]) out.add(m[1]);\n    }\n  }\n  return [...out].sort();\n}\n\n/**\n * Path overlap: returns true if `a` and `b` refer to the same path or one is a\n * parent of the other. Both inputs are treated as POSIX-style relative paths.\n */\nexport function pathsOverlap(a: string, b: string): boolean {\n  const na = normalize(a);\n  const nb = normalize(b);\n  if (na === nb) return true;\n  return na.startsWith(nb + \"/\") || nb.startsWith(na + \"/\");\n}\n\nexport function memoryMatchesAnchorPaths(\n  memory: LoadedMemory[\"memory\"],\n  inputPaths: string[],\n): boolean {\n  const anchorPaths = memory.frontmatter.anchor.paths;\n  if (anchorPaths.length === 0) return false;\n  for (const ap of anchorPaths) {\n    for (const ip of inputPaths) {\n      if (pathsOverlap(ap, ip)) return true;\n    }\n  }\n  return false;\n}\n\nfunction normalize(p: string): string {\n  // Strip leading \"./\" and trailing \"/\", normalize separators.\n  return p.replace(/\\\\/g, \"/\").replace(/^\\.\\//, \"\").replace(/\\/+$/, \"\");\n}\n\nexport function relPathFrom(root: string, abs: string): string {\n  return path.relative(root, abs).replace(/\\\\/g, \"/\");\n}\n"],"mappings":"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","names":["path","path","readFile","existsSync","path","readFile","existsSync","path","path"]}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@hiveai/core",
+  "version": "0.1.0",
+  "description": "hAIve core — memory types, schema, parser, validator",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Doucs91/hAIve.git",
+    "directory": "packages/core"
+  },
+  "bugs": "https://github.com/Doucs91/hAIve/issues",
+  "homepage": "https://github.com/Doucs91/hAIve#readme",
+  "keywords": [
+    "ai",
+    "memory",
+    "mcp",
+    "haive",
+    "agent",
+    "team"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "zod": "^3.23.8"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist .tsbuildinfo"
+  }
+}