@plur-ai/core 0.2.8 → 0.3.0

package/dist/index.d.ts

@@ -46,6 +46,7 @@ declare const EngramSchema: z.ZodObject<{
     statement: z.ZodString;
     rationale: z.ZodOptional<z.ZodString>;
     contraindications: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    source: z.ZodOptional<z.ZodString>;
     source_patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     derivation_count: z.ZodDefault<z.ZodNumber>;
     pack: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -299,6 +300,7 @@ declare const EngramSchema: z.ZodObject<{
     };
     rationale?: string | undefined;
     contraindications?: string[] | undefined;
+    source?: string | undefined;
     source_patterns?: string[] | undefined;
     episodic?: {
         emotional_weight: number;
@@ -362,6 +364,7 @@ declare const EngramSchema: z.ZodObject<{
     visibility?: "private" | "public" | "template" | undefined;
     rationale?: string | undefined;
     contraindications?: string[] | undefined;
+    source?: string | undefined;
     source_patterns?: string[] | undefined;
     derivation_count?: number | undefined;
     pack?: string | null | undefined;

package/dist/index.js

@@ -158,6 +158,7 @@ var EngramSchema = z2.object({
   rationale: z2.string().optional(),
   contraindications: z2.array(z2.string()).optional(),
   // Lineage
+  source: z2.string().optional(),
   source_patterns: z2.array(z2.string()).optional(),
   derivation_count: z2.number().int().min(0).default(1),
   pack: z2.string().nullable().default(null),
@@ -242,6 +243,168 @@ var logger = {
   }
 };
 
+// src/sync.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3, writeFileSync, renameSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, dirname } from "path";
+var GITIGNORE = `# PLUR \u2014 derived/cache files (regenerated automatically)
+embeddings/
+.embeddings-cache.json
+*.db
+*.sqlite
+exchange/
+`;
+function git(args, cwd) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
+}
+function gitSafe(args, cwd) {
+  try {
+    return git(args, cwd);
+  } catch {
+    return null;
+  }
+}
+function isGitRepo(root) {
+  return existsSync3(join2(root, ".git"));
+}
+function hasGitCli() {
+  try {
+    execFileSync("git", ["--version"], { encoding: "utf8", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getRemote(root) {
+  return gitSafe(["remote", "get-url", "origin"], root);
+}
+function isDirty(root) {
+  const status = gitSafe(["status", "--porcelain"], root);
+  return status !== null && status.length > 0;
+}
+function countDiff(root, direction) {
+  const tracking = gitSafe(["rev-parse", "--abbrev-ref", "@{u}"], root);
+  if (!tracking) return 0;
+  const flag = direction === "ahead" ? "--left-only" : "--right-only";
+  const count = gitSafe(["rev-list", flag, "--count", "HEAD...@{u}"], root);
+  return count ? parseInt(count, 10) : 0;
+}
+function getSyncStatus(root) {
+  if (!isGitRepo(root)) {
+    return { initialized: false, remote: null, dirty: false, branch: null, ahead: 0, behind: 0 };
+  }
+  const branch = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"], root);
+  const remote = getRemote(root);
+  if (remote) gitSafe(["fetch", "origin", "--quiet"], root);
+  return {
+    initialized: true,
+    remote,
+    dirty: isDirty(root),
+    branch,
+    ahead: countDiff(root, "ahead"),
+    behind: countDiff(root, "behind")
+  };
+}
+function initRepo(root) {
+  git(["init"], root);
+  atomicWrite(join2(root, ".gitignore"), GITIGNORE);
+  git(["add", "-A"], root);
+  git(["commit", "-m", "Initial PLUR engram store"], root);
+}
+function commitChanges(root) {
+  if (!isDirty(root)) return 0;
+  git(["add", "-A"], root);
+  const diff = gitSafe(["diff", "--cached", "--stat", "--shortstat"], root);
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+  git(["commit", "-m", `plur sync ${now}`], root);
+  const match = diff?.match(/(\d+) file/);
+  return match ? parseInt(match[1], 10) : 1;
+}
+function hasConflictMarkers(root) {
+  const result = gitSafe(["grep", "-l", "<<<<<<<"], root);
+  return result !== null && result.length > 0;
+}
+function pullRebase(root) {
+  const result = gitSafe(["pull", "--rebase", "origin", "main"], root);
+  if (result !== null) return true;
+  gitSafe(["rebase", "--abort"], root);
+  const mergeResult = gitSafe(["pull", "origin", "main", "--no-edit"], root);
+  if (mergeResult !== null) return true;
+  if (hasConflictMarkers(root)) {
+    gitSafe(["merge", "--abort"], root);
+    throw new Error("Sync conflict: YAML files have merge conflicts that require manual resolution. Your local changes are preserved.");
+  }
+  git(["add", "-A"], root);
+  gitSafe(["commit", "-m", "plur sync: merge conflict resolved (kept both)"], root);
+  return true;
+}
+function sync(root, remote) {
+  if (!hasGitCli()) {
+    throw new Error("git is not installed. Install git to enable sync.");
+  }
+  if (!isGitRepo(root)) {
+    initRepo(root);
+    if (remote) {
+      git(["remote", "add", "origin", remote], root);
+      const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root);
+      git(["push", "-u", "origin", branch], root);
+      return { action: "initialized", message: `Initialized and pushed to ${remote}`, remote, files_changed: 0 };
+    }
+    return {
+      action: "initialized",
+      message: "Initialized local git repo. Call plur.sync with remote to enable cross-device sync.",
+      remote: null,
+      files_changed: 0
+    };
+  }
+  const existingRemote = getRemote(root);
+  if (remote && !existingRemote) {
+    git(["remote", "add", "origin", remote], root);
+    const filesChanged2 = commitChanges(root);
+    const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root);
+    git(["push", "-u", "origin", branch], root);
+    return { action: "synced", message: `Remote added and pushed to ${remote}`, remote, files_changed: filesChanged2 };
+  }
+  if (!existingRemote) {
+    const filesChanged2 = commitChanges(root);
+    if (filesChanged2 === 0) {
+      return { action: "up-to-date", message: 'No changes to commit. Add a remote with plur.sync({ remote: "..." }) to enable cross-device sync.', remote: null, files_changed: 0 };
+    }
+    return { action: "committed", message: `Committed ${filesChanged2} file(s) locally.`, remote: null, files_changed: filesChanged2 };
+  }
+  const filesChanged = commitChanges(root);
+  gitSafe(["fetch", "origin", "--quiet"], root);
+  const behind = countDiff(root, "behind");
+  const aheadBefore = countDiff(root, "ahead");
+  if (behind > 0) {
+    pullRebase(root);
+  }
+  const aheadAfter = countDiff(root, "ahead");
+  if (aheadAfter > 0) {
+    gitSafe(["push", "origin"], root);
+  }
+  if (filesChanged === 0 && behind === 0 && aheadBefore === 0) {
+    return { action: "up-to-date", message: "Already in sync.", remote: existingRemote, files_changed: 0 };
+  }
+  const parts = [];
+  if (filesChanged > 0) parts.push(`${filesChanged} file(s) committed`);
+  if (behind > 0) parts.push(`pulled ${behind} remote commit(s)`);
+  if (aheadAfter === 0 && aheadBefore > 0) parts.push("pushed");
+  return {
+    action: "synced",
+    message: `Synced. ${parts.join(", ")}.`,
+    remote: existingRemote,
+    files_changed: filesChanged
+  };
+}
+function atomicWrite(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+  const tmp = filePath + ".tmp";
+  writeFileSync(tmp, content);
+  renameSync(tmp, filePath);
+}
+
 // src/engrams.ts
 function loadEngrams(filePath) {
   if (!fs.existsSync(filePath)) return [];
@@ -264,7 +427,7 @@ function loadEngrams(filePath) {
 }
 function saveEngrams(filePath, engrams) {
   const content = yaml2.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
-  fs.writeFileSync(filePath, content);
+  atomicWrite(filePath, content);
 }
 function parseSkillMdFrontmatter(filePath) {
   const content = fs.readFileSync(filePath, "utf8");
@@ -635,7 +798,7 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
 }
 
 // src/episodes.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import yaml3 from "js-yaml";
 function generateEpisodeId() {
   const ts = Date.now();
@@ -654,7 +817,7 @@ function captureEpisode(path2, summary, context) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   episodes.push(episode);
-  writeFileSync2(path2, yaml3.dump(episodes, { lineWidth: 120, noRefs: true }), "utf8");
+  atomicWrite(path2, yaml3.dump(episodes, { lineWidth: 120, noRefs: true }));
   return episode;
 }
 function queryTimeline(path2, query) {
@@ -670,7 +833,7 @@ function queryTimeline(path2, query) {
   return episodes;
 }
 function loadEpisodes(path2) {
-  if (!existsSync4(path2)) return [];
+  if (!existsSync5(path2)) return [];
   try {
     const raw = yaml3.load(readFileSync3(path2, "utf8"));
     return Array.isArray(raw) ? raw : [];
@@ -743,8 +906,9 @@ Rules:
 }
 
 // src/embeddings.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+import { createHash } from "crypto";
 var embedPipeline = null;
 var transformersUnavailable = false;
 async function getEmbedder() {
@@ -774,7 +938,7 @@ function cosineSimilarity(a, b) {
   return dot;
 }
 function loadCache(cachePath) {
-  if (!existsSync5(cachePath)) return {};
+  if (!existsSync6(cachePath)) return {};
   try {
     return JSON.parse(readFileSync4(cachePath, "utf8"));
   } catch {
@@ -783,19 +947,15 @@ function loadCache(cachePath) {
 }
 function saveCache(cachePath, cache2) {
   const dir = cachePath.substring(0, cachePath.lastIndexOf("/"));
-  if (!existsSync5(dir)) mkdirSync2(dir, { recursive: true });
-  writeFileSync3(cachePath, JSON.stringify(cache2));
+  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  atomicWrite(cachePath, JSON.stringify(cache2));
 }
 function hashStatement(statement) {
-  let hash = 0;
-  for (let i = 0; i < statement.length; i++) {
-    hash = (hash << 5) - hash + statement.charCodeAt(i) | 0;
-  }
-  return hash.toString(36);
+  return createHash("sha256").update(statement).digest("hex").slice(0, 16);
 }
 async function embeddingSearch(engrams, query, limit, storagePath) {
   if (engrams.length === 0) return [];
-  const cachePath = storagePath ? join2(storagePath, ".embeddings-cache.json") : ".embeddings-cache.json";
+  const cachePath = storagePath ? join3(storagePath, ".embeddings-cache.json") : ".embeddings-cache.json";
   const cache2 = loadCache(cachePath);
   const queryEmbedding = await embed(query);
   if (!queryEmbedding) {
@@ -1023,152 +1183,6 @@ ${manifest.description || ""}
   return { path: outputDir, engram_count: engrams.length };
 }
 
-// src/sync.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync7, writeFileSync as writeFileSync5 } from "fs";
-import { join as join4 } from "path";
-var GITIGNORE = `# PLUR \u2014 derived/cache files (regenerated automatically)
-embeddings/
-*.db
-*.sqlite
-exchange/
-`;
-function git(args, cwd) {
-  return execSync(`git ${args}`, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
-}
-function gitSafe(args, cwd) {
-  try {
-    return git(args, cwd);
-  } catch {
-    return null;
-  }
-}
-function isGitRepo(root) {
-  return existsSync7(join4(root, ".git"));
-}
-function hasGitCli() {
-  try {
-    execSync("git --version", { encoding: "utf8", timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getRemote(root) {
-  return gitSafe("remote get-url origin", root);
-}
-function isDirty(root) {
-  const status = gitSafe("status --porcelain", root);
-  return status !== null && status.length > 0;
-}
-function countDiff(root, direction) {
-  const tracking = gitSafe("rev-parse --abbrev-ref @{u}", root);
-  if (!tracking) return 0;
-  const flag = direction === "ahead" ? "left" : "right";
-  const count = gitSafe(`rev-list --${flag}-only --count HEAD...@{u}`, root);
-  return count ? parseInt(count, 10) : 0;
-}
-function getSyncStatus(root) {
-  if (!isGitRepo(root)) {
-    return { initialized: false, remote: null, dirty: false, branch: null, ahead: 0, behind: 0 };
-  }
-  const branch = gitSafe("rev-parse --abbrev-ref HEAD", root);
-  const remote = getRemote(root);
-  if (remote) gitSafe("fetch origin --quiet", root);
-  return {
-    initialized: true,
-    remote,
-    dirty: isDirty(root),
-    branch,
-    ahead: countDiff(root, "ahead"),
-    behind: countDiff(root, "behind")
-  };
-}
-function initRepo(root) {
-  git("init", root);
-  writeFileSync5(join4(root, ".gitignore"), GITIGNORE);
-  git("add -A", root);
-  git('commit -m "Initial PLUR engram store"', root);
-}
-function commitChanges(root) {
-  if (!isDirty(root)) return 0;
-  git("add -A", root);
-  const diff = gitSafe("diff --cached --stat --shortstat", root);
-  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
-  git(`commit -m "plur sync ${now}"`, root);
-  const match = diff?.match(/(\d+) file/);
-  return match ? parseInt(match[1], 10) : 1;
-}
-function pullRebase(root) {
-  const result = gitSafe("pull --rebase origin main", root);
-  if (result !== null) return true;
-  gitSafe("rebase --abort", root);
-  const mergeResult = gitSafe("pull origin main --no-edit", root);
-  if (mergeResult !== null) return true;
-  git("add -A", root);
-  gitSafe('commit -m "plur sync: merge conflict resolved (kept both)"', root);
-  return true;
-}
-function sync(root, remote) {
-  if (!hasGitCli()) {
-    throw new Error("git is not installed. Install git to enable sync.");
-  }
-  if (!isGitRepo(root)) {
-    initRepo(root);
-    if (remote) {
-      git(`remote add origin ${remote}`, root);
-      const branch = git("rev-parse --abbrev-ref HEAD", root);
-      git(`push -u origin ${branch}`, root);
-      return { action: "initialized", message: `Initialized and pushed to ${remote}`, remote, files_changed: 0 };
-    }
-    return {
-      action: "initialized",
-      message: "Initialized local git repo. Call plur.sync with remote to enable cross-device sync.",
-      remote: null,
-      files_changed: 0
-    };
-  }
-  const existingRemote = getRemote(root);
-  if (remote && !existingRemote) {
-    git(`remote add origin ${remote}`, root);
-    const filesChanged2 = commitChanges(root);
-    const branch = git("rev-parse --abbrev-ref HEAD", root);
-    git(`push -u origin ${branch}`, root);
-    return { action: "synced", message: `Remote added and pushed to ${remote}`, remote, files_changed: filesChanged2 };
-  }
-  if (!existingRemote) {
-    const filesChanged2 = commitChanges(root);
-    if (filesChanged2 === 0) {
-      return { action: "up-to-date", message: 'No changes to commit. Add a remote with plur.sync({ remote: "..." }) to enable cross-device sync.', remote: null, files_changed: 0 };
-    }
-    return { action: "committed", message: `Committed ${filesChanged2} file(s) locally.`, remote: null, files_changed: filesChanged2 };
-  }
-  const filesChanged = commitChanges(root);
-  gitSafe("fetch origin --quiet", root);
-  const behind = countDiff(root, "behind");
-  const aheadBefore = countDiff(root, "ahead");
-  if (behind > 0) {
-    pullRebase(root);
-  }
-  const aheadAfter = countDiff(root, "ahead");
-  if (aheadAfter > 0) {
-    gitSafe("push origin", root);
-  }
-  if (filesChanged === 0 && behind === 0 && aheadBefore === 0) {
-    return { action: "up-to-date", message: "Already in sync.", remote: existingRemote, files_changed: 0 };
-  }
-  const parts = [];
-  if (filesChanged > 0) parts.push(`${filesChanged} file(s) committed`);
-  if (behind > 0) parts.push(`pulled ${behind} remote commit(s)`);
-  if (aheadAfter === 0 && aheadBefore > 0) parts.push("pushed");
-  return {
-    action: "synced",
-    message: `Synced. ${parts.join(", ")}.`,
-    remote: existingRemote,
-    files_changed: filesChanged
-  };
-}
-
 // src/version-check.ts
 var cache = /* @__PURE__ */ new Map();
 async function checkForUpdate(packageName, currentVersion, onResult) {
@@ -1252,6 +1266,7 @@ var Plur = class {
       scope,
       visibility: "private",
       statement,
+      source: context?.source,
       domain: context?.domain,
       activation: {
         retrieval_strength: 0.7,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plur-ai/core",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,9 +38,8 @@
   "author": "PLUR <info@plur.ai>",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "scripts": {