@plur-ai/core 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -545,13 +545,60 @@ declare const PackManifestSchema: z.ZodObject<{
 }>;
 type PackManifest = z.infer<typeof PackManifestSchema>;
 
+interface InstallResult {
+    installed: number;
+    name: string;
+    conflicts: ConflictItem[];
+}
+interface ConflictItem {
+    pack_engram_id: string;
+    pack_statement: string;
+    existing_engram_id: string;
+    existing_statement: string;
+    type: 'contradiction' | 'duplicate';
+}
+declare function installPack(packsDir: string, source: string, existingEngrams?: Engram[]): InstallResult;
+interface UninstallResult {
+    name: string;
+    removed: boolean;
+    engram_count: number;
+}
+declare function uninstallPack(packsDir: string, name: string): UninstallResult;
 interface PackInfo {
     name: string;
     path: string;
     engram_count: number;
     manifest?: PackManifest;
+    integrity?: string;
 }
 declare function listPacks(packsDir: string): PackInfo[];
+interface ExportOptions {
+    name: string;
+    version: string;
+    description?: string;
+    creator?: string;
+    domain?: string;
+    scope?: string;
+    tags?: string[];
+    type?: string;
+}
+interface PrivacyScanResult {
+    clean: boolean;
+    issues: PrivacyIssue[];
+}
+interface PrivacyIssue {
+    engram_id: string;
+    type: 'secret' | 'private_visibility' | 'personal_path' | 'email' | 'ip_address';
+    detail: string;
+}
+interface ExportResult {
+    path: string;
+    engram_count: number;
+    privacy: PrivacyScanResult;
+    match_terms: string[];
+    integrity: string;
+}
+declare function exportPack(engrams: Engram[], outputDir: string, manifest: ExportOptions): ExportResult;
 
 interface SyncStatus {
     initialized: boolean;
@@ -804,14 +851,14 @@ declare const StructuralTemplateSchema: z.ZodObject<{
     goal_type: string;
     constraint_type: string;
     outcome_type: string;
-    structure_type: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform";
+    structure_type: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform";
     freeform_structure?: string | undefined;
 }, {
     template: string;
     goal_type: string;
     constraint_type: string;
     outcome_type: string;
-    structure_type?: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform" | undefined;
+    structure_type?: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform" | undefined;
     freeform_structure?: string | undefined;
 }>;
 declare const EvidenceEntrySchema: z.ZodObject<{
@@ -904,14 +951,14 @@ declare const MetaFieldSchema: z.ZodObject<{
         goal_type: string;
         constraint_type: string;
         outcome_type: string;
-        structure_type: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform";
+        structure_type: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform";
         freeform_structure?: string | undefined;
     }, {
         template: string;
         goal_type: string;
         constraint_type: string;
         outcome_type: string;
-        structure_type?: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform" | undefined;
+        structure_type?: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform" | undefined;
         freeform_structure?: string | undefined;
     }>;
     evidence: z.ZodArray<z.ZodObject<{
@@ -1003,7 +1050,7 @@ declare const MetaFieldSchema: z.ZodObject<{
         goal_type: string;
         constraint_type: string;
         outcome_type: string;
-        structure_type: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform";
+        structure_type: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform";
         freeform_structure?: string | undefined;
     };
     evidence: {
@@ -1042,7 +1089,7 @@ declare const MetaFieldSchema: z.ZodObject<{
         goal_type: string;
         constraint_type: string;
         outcome_type: string;
-        structure_type?: "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "recursive" | "tradeoff" | "freeform" | undefined;
+        structure_type?: "recursive" | "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "freeform" | undefined;
         freeform_structure?: string | undefined;
     };
     evidence: {
@@ -1385,22 +1432,18 @@ declare class Plur {
     timeline(query?: TimelineQuery): Episode[];
     /** Rule-based extraction of engram candidates from content. */
     ingest(content: string, options?: IngestOptions): IngestCandidate[];
-    /** Install a pack from a source path. */
-    installPack(source: string): {
-        installed: number;
-        name: string;
-    };
-    /** Export engrams as a shareable pack. */
+    /** Install a pack from a source path. Detects conflicts with existing engrams. */
+    installPack(source: string): ReturnType<typeof installPack>;
+    /** Uninstall a pack by name. */
+    uninstallPack(name: string): ReturnType<typeof uninstallPack>;
+    /** Export engrams as a shareable pack with privacy scanning and integrity hash. */
     exportPack(engrams: Engram[], outputDir: string, manifest: {
         name: string;
         version: string;
         description?: string;
         creator?: string;
-    }): {
-        path: string;
-        engram_count: number;
-    };
-    /** List all installed packs. */
+    }): ReturnType<typeof exportPack>;
+    /** List all installed packs (with integrity hashes). */
     listPacks(): ReturnType<typeof listPacks>;
     /** Sync engrams to git. Initializes repo on first call, commits + push/pull on subsequent calls. */
     sync(remote?: string): SyncResult;

package/dist/index.js

@@ -1062,25 +1062,110 @@ async function expandedSearch(engrams, query, limit, llm, storagePath) {
 // src/packs.ts
 import * as fs2 from "fs";
 import * as path from "path";
+import * as crypto from "crypto";
 import yaml4 from "js-yaml";
-function installPack(packsDir, source) {
+
+// src/secrets.ts
+var SECRET_PATTERNS = [
+  { name: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/ },
+  { name: "aws_secret_key", regex: /(?:aws_secret_access_key|secret_access_key)\s*[=:]\s*[A-Za-z0-9/+=]{40}/i },
+  { name: "generic_api_key", regex: /(?:^|[^a-z])(sk|pk)[-_][a-z0-9]{20,}/i },
+  { name: "api_key_assignment", regex: /(?:api[_-]?key|api[_-]?secret|secret[_-]?key)\s*[=:]\s*\S{20,}/i },
+  { name: "password_assignment", regex: /password\s*[=:]\s*\S{8,}/i },
+  { name: "connection_string", regex: /(?:postgres|mysql|mongodb|redis):\/\/\S+/ },
+  { name: "jwt", regex: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}/ },
+  { name: "private_key", regex: /-----BEGIN\s+\S+\s+PRIVATE KEY-----/ },
+  { name: "bearer_token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/ }
+];
+function detectSecrets(text) {
+  const matches = [];
+  for (const { name, regex } of SECRET_PATTERNS) {
+    const m = text.match(regex);
+    if (m) {
+      matches.push({ pattern: name, match: m[0].slice(0, 20) + "..." });
+    }
+  }
+  return matches;
+}
+
+// src/packs.ts
+function detectConflicts2(newEngrams, existingEngrams) {
+  const conflicts = [];
+  for (const ne of newEngrams) {
+    for (const ee of existingEngrams) {
+      const nNorm = ne.statement.toLowerCase().replace(/\s+/g, " ").trim();
+      const eNorm = ee.statement.toLowerCase().replace(/\s+/g, " ").trim();
+      if (nNorm === eNorm) {
+        conflicts.push({
+          pack_engram_id: ne.id,
+          pack_statement: ne.statement.slice(0, 120),
+          existing_engram_id: ee.id,
+          existing_statement: ee.statement.slice(0, 120),
+          type: "duplicate"
+        });
+        continue;
+      }
+      if (ne.domain && ee.domain && ne.domain === ee.domain) {
+        const nHasNever = /\b(never|don't|do not|avoid|stop)\b/i.test(ne.statement);
+        const eHasNever = /\b(never|don't|do not|avoid|stop)\b/i.test(ee.statement);
+        const nHasAlways = /\b(always|must|should|prefer|use)\b/i.test(ne.statement);
+        const eHasAlways = /\b(always|must|should|prefer|use)\b/i.test(ee.statement);
+        if (nHasNever && eHasAlways || nHasAlways && eHasNever) {
+          const nWords = new Set(nNorm.split(" ").filter((w) => w.length > 4));
+          const eWords = new Set(eNorm.split(" ").filter((w) => w.length > 4));
+          const overlap = [...nWords].filter((w) => eWords.has(w));
+          if (overlap.length >= 2) {
+            conflicts.push({
+              pack_engram_id: ne.id,
+              pack_statement: ne.statement.slice(0, 120),
+              existing_engram_id: ee.id,
+              existing_statement: ee.statement.slice(0, 120),
+              type: "contradiction"
+            });
+          }
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function installPack(packsDir, source, existingEngrams) {
   if (!fs2.existsSync(source)) throw new Error(`Pack source not found: ${source}`);
   const sourceName = path.basename(source);
   const destDir = path.join(packsDir, sourceName);
   if (!fs2.existsSync(destDir)) fs2.mkdirSync(destDir, { recursive: true });
   const files = fs2.readdirSync(source);
-  let copied = 0;
   for (const file of files) {
     const srcPath = path.join(source, file);
     const destPath = path.join(destDir, file);
     if (fs2.statSync(srcPath).isFile()) {
       fs2.copyFileSync(srcPath, destPath);
-      copied++;
     }
   }
   const engramsPath = path.join(destDir, "engrams.yaml");
-  const engrams = fs2.existsSync(engramsPath) ? loadEngrams(engramsPath) : [];
-  return { installed: engrams.length, name: sourceName };
+  const newEngrams = fs2.existsSync(engramsPath) ? loadEngrams(engramsPath) : [];
+  const conflicts = existingEngrams ? detectConflicts2(newEngrams, existingEngrams) : [];
+  return { installed: newEngrams.length, name: sourceName, conflicts };
+}
+function uninstallPack(packsDir, name) {
+  let packDir = path.join(packsDir, name);
+  if (!fs2.existsSync(packDir)) {
+    const entries = fs2.existsSync(packsDir) ? fs2.readdirSync(packsDir) : [];
+    const match = entries.find((e) => e.toLowerCase() === name.toLowerCase());
+    if (match) {
+      packDir = path.join(packsDir, match);
+    } else {
+      throw new Error(`Pack not found: ${name}. Use 'plur packs list' to see installed packs.`);
+    }
+  }
+  const engramsPath = path.join(packDir, "engrams.yaml");
+  let count = 0;
+  try {
+    count = loadEngrams(engramsPath).length;
+  } catch {
+  }
+  fs2.rmSync(packDir, { recursive: true, force: true });
+  return { name, removed: true, engram_count: count };
 }
 function listPacks(packsDir) {
   if (!fs2.existsSync(packsDir)) return [];
@@ -1094,7 +1179,8 @@ function listPacks(packsDir) {
         name: pack.manifest.name,
         path: packDir,
         engram_count: pack.engrams.length,
-        manifest: pack.manifest
+        manifest: pack.manifest,
+        integrity: computePackHash(packDir)
       });
     } catch {
       const engramsPath = path.join(packDir, "engrams.yaml");
@@ -1108,7 +1194,83 @@ function listPacks(packsDir) {
   }
   return result;
 }
+var PERSONAL_PATH_RE = /(?:\/Users\/\w+|\/home\/\w+|~\/|C:\\Users\\\w+)/;
+var EMAIL_RE = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/;
+var IP_RE = /\b(?:10|172\.(?:1[6-9]|2\d|3[01])|192\.168)\.\d{1,3}\.\d{1,3}\b/;
+function scanPrivacy(engrams) {
+  const issues = [];
+  for (const e of engrams) {
+    if (e.visibility === "private") {
+      issues.push({
+        engram_id: e.id,
+        type: "private_visibility",
+        detail: `Engram marked as private \u2014 skipped from export`
+      });
+      continue;
+    }
+    const text = `${e.statement} ${e.rationale ?? ""} ${e.source ?? ""}`;
+    const secrets = detectSecrets(text);
+    for (const s of secrets) {
+      issues.push({
+        engram_id: e.id,
+        type: "secret",
+        detail: `${s.pattern}: ${s.match}`
+      });
+    }
+    if (PERSONAL_PATH_RE.test(text)) {
+      issues.push({
+        engram_id: e.id,
+        type: "personal_path",
+        detail: `Contains personal path: ${text.match(PERSONAL_PATH_RE)?.[0]}`
+      });
+    }
+    const emailMatch = text.match(EMAIL_RE);
+    if (emailMatch) {
+      issues.push({
+        engram_id: e.id,
+        type: "email",
+        detail: `Contains email: ${emailMatch[0]}`
+      });
+    }
+    const ipMatch = text.match(IP_RE);
+    if (ipMatch) {
+      issues.push({
+        engram_id: e.id,
+        type: "ip_address",
+        detail: `Contains private IP: ${ipMatch[0]}`
+      });
+    }
+  }
+  return { clean: issues.length === 0, issues };
+}
+function deriveMatchTerms(engrams) {
+  const termCounts = /* @__PURE__ */ new Map();
+  for (const e of engrams) {
+    if (e.tags) {
+      for (const t of e.tags) {
+        termCounts.set(t, (termCounts.get(t) || 0) + 1);
+      }
+    }
+    if (e.domain) {
+      for (const part of e.domain.split(".")) {
+        if (part.length > 2) {
+          termCounts.set(part, (termCounts.get(part) || 0) + 1);
+        }
+      }
+    }
+    if (e.type) {
+      termCounts.set(e.type, (termCounts.get(e.type) || 0) + 1);
+    }
+  }
+  return [...termCounts.entries()].filter(([, count]) => count >= 2).sort((a, b) => b[1] - a[1]).slice(0, 20).map(([term]) => term);
+}
 function exportPack(engrams, outputDir, manifest) {
+  const allPrivacy = scanPrivacy(engrams);
+  const blockedIds = new Set(
+    allPrivacy.issues.filter((i) => i.type === "secret" || i.type === "private_visibility").map((i) => i.engram_id)
+  );
+  const safeEngrams = engrams.filter((e) => !blockedIds.has(e.id));
+  const matchTerms = deriveMatchTerms(safeEngrams);
   if (!fs2.existsSync(outputDir)) fs2.mkdirSync(outputDir, { recursive: true });
   const frontmatter = yaml4.dump({
     name: manifest.name,
@@ -1117,8 +1279,8 @@ function exportPack(engrams, outputDir, manifest) {
     creator: manifest.creator,
     metadata: {
       injection_policy: "on_match",
-      match_terms: [],
-      engram_count: engrams.length
+      match_terms: matchTerms,
+      engram_count: safeEngrams.length
     }
   });
   fs2.writeFileSync(
@@ -1131,32 +1293,60 @@ ${frontmatter}---
 ${manifest.description || ""}
 `
   );
-  const content = yaml4.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const exportEngrams = safeEngrams.map((e) => {
+    const cleaned = { ...e };
+    if (cleaned.relations) {
+      cleaned.relations = {
+        ...cleaned.relations,
+        conflicts: [],
+        related: []
+      };
+    }
+    if (cleaned.associations) {
+      cleaned.associations = [];
+    }
+    if (cleaned.knowledge_anchors) {
+      cleaned.knowledge_anchors = [];
+    }
+    if (cleaned.activation) {
+      cleaned.activation = {
+        ...cleaned.activation,
+        frequency: 0,
+        retrieval_strength: 0.7
+      };
+    }
+    if (cleaned.feedback_signals) {
+      cleaned.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+    }
+    return cleaned;
+  });
+  const content = yaml4.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
   fs2.writeFileSync(path.join(outputDir, "engrams.yaml"), content);
-  return { path: outputDir, engram_count: engrams.length };
+  const integrity = computePackHash(outputDir);
+  fs2.writeFileSync(path.join(outputDir, "INTEGRITY"), `sha256:${integrity}
+`);
+  return {
+    path: outputDir,
+    engram_count: safeEngrams.length,
+    privacy: allPrivacy,
+    match_terms: matchTerms,
+    integrity: `sha256:${integrity}`
+  };
 }
-
-// src/secrets.ts
-var SECRET_PATTERNS = [
-  { name: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/ },
-  { name: "aws_secret_key", regex: /(?:aws_secret_access_key|secret_access_key)\s*[=:]\s*[A-Za-z0-9/+=]{40}/i },
-  { name: "generic_api_key", regex: /(?:^|[^a-z])(sk|pk)[-_][a-z0-9]{20,}/i },
-  { name: "api_key_assignment", regex: /(?:api[_-]?key|api[_-]?secret|secret[_-]?key)\s*[=:]\s*\S{20,}/i },
-  { name: "password_assignment", regex: /password\s*[=:]\s*\S{8,}/i },
-  { name: "connection_string", regex: /(?:postgres|mysql|mongodb|redis):\/\/\S+/ },
-  { name: "jwt", regex: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}/ },
-  { name: "private_key", regex: /-----BEGIN\s+\S+\s+PRIVATE KEY-----/ },
-  { name: "bearer_token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/ }
-];
-function detectSecrets(text) {
-  const matches = [];
-  for (const { name, regex } of SECRET_PATTERNS) {
-    const m = text.match(regex);
-    if (m) {
-      matches.push({ pattern: name, match: m[0].slice(0, 20) + "..." });
-    }
+function computePackHash(packDir) {
+  const hash = crypto.createHash("sha256");
+  const skillMd = path.join(packDir, "SKILL.md");
+  const manifestYaml = path.join(packDir, "manifest.yaml");
+  if (fs2.existsSync(skillMd)) {
+    hash.update(fs2.readFileSync(skillMd));
+  } else if (fs2.existsSync(manifestYaml)) {
+    hash.update(fs2.readFileSync(manifestYaml));
   }
-  return matches;
+  const engramsPath = path.join(packDir, "engrams.yaml");
+  if (fs2.existsSync(engramsPath)) {
+    hash.update(fs2.readFileSync(engramsPath));
+  }
+  return hash.digest("hex");
 }
 
 // src/meta/sanitize.ts
@@ -2555,15 +2745,20 @@ var Plur = class {
     }
     return candidates;
   }
-  /** Install a pack from a source path. */
+  /** Install a pack from a source path. Detects conflicts with existing engrams. */
   installPack(source) {
-    return installPack(this.paths.packs, source);
+    const existing = this._loadAllEngrams();
+    return installPack(this.paths.packs, source, existing);
+  }
+  /** Uninstall a pack by name. */
+  uninstallPack(name) {
+    return uninstallPack(this.paths.packs, name);
   }
-  /** Export engrams as a shareable pack. */
+  /** Export engrams as a shareable pack with privacy scanning and integrity hash. */
   exportPack(engrams, outputDir, manifest) {
     return exportPack(engrams, outputDir, manifest);
   }
-  /** List all installed packs. */
+  /** List all installed packs (with integrity hashes). */
   listPacks() {
     return listPacks(this.paths.packs);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plur-ai/core",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",