@iamem/amem 0.1.0

package/dist/policy.js

@@ -0,0 +1,254 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { platform as osPlatform } from "node:os";
+import { join } from "node:path";
+import { amemHome } from "./paths.js";
+import { KNOWN_PLATFORMS } from "./platforms.js";
+/** Built-in secret hygiene — always active; policy patterns extend these. */
+export const BUILTIN_DENY_CLAIM_PATTERNS = [
+    "api[_-]?key",
+    "-----BEGIN",
+    "password\\s*=",
+    "secret\\s*=",
+    "private[_-]?key",
+    "aws[_-]?secret",
+    "xox[baprs]-",
+];
+export const DEFAULT_POLICY = {
+    telemetry: false,
+    ui_enabled: true,
+    ui_bind: "127.0.0.1",
+    allow_export: true,
+    allowed_platforms: KNOWN_PLATFORMS.map((p) => p.id),
+    allowed_remote_hosts: [],
+    deny_claim_patterns: [],
+    auto_apply_kinds: [],
+};
+let cached = null;
+export function clearPolicyCache() {
+    cached = null;
+}
+export function systemPolicyPath() {
+    if (process.env.AMEM_SYSTEM_POLICY)
+        return process.env.AMEM_SYSTEM_POLICY;
+    if (osPlatform() === "win32") {
+        const base = process.env.ProgramData ?? "C:\\ProgramData";
+        return join(base, "amem", "policy.toml");
+    }
+    return "/etc/amem/policy.toml";
+}
+export function userPolicyPath() {
+    return join(amemHome(), "policy.toml");
+}
+/**
+ * Minimal TOML subset for amem policy files:
+ * booleans, quoted strings, and string arrays. Comments (#) and blank lines ok.
+ */
+export function parsePolicyToml(raw) {
+    const out = {};
+    const lines = raw.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].replace(/#.*$/, "").trim();
+        if (!line)
+            continue;
+        const eq = line.indexOf("=");
+        if (eq <= 0) {
+            throw new Error(`Invalid policy line ${i + 1}: ${line}`);
+        }
+        const key = line.slice(0, eq).trim();
+        const valueRaw = line.slice(eq + 1).trim();
+        switch (key) {
+            case "telemetry":
+            case "ui_enabled":
+            case "allow_export":
+                out[key] = parseBool(valueRaw, key, i + 1);
+                break;
+            case "ui_bind":
+                out.ui_bind = parseString(valueRaw, key, i + 1);
+                break;
+            case "allowed_platforms":
+            case "allowed_remote_hosts":
+            case "deny_claim_patterns":
+            case "auto_apply_kinds":
+                out[key] = parseStringArray(valueRaw, key, i + 1);
+                break;
+            default:
+                throw new Error(`Unknown policy key on line ${i + 1}: ${key}`);
+        }
+    }
+    return out;
+}
+function parseBool(raw, key, line) {
+    if (raw === "true")
+        return true;
+    if (raw === "false")
+        return false;
+    throw new Error(`Policy ${key} on line ${line} must be true or false`);
+}
+function parseString(raw, key, line) {
+    const m = /^"(.*)"$/.exec(raw);
+    if (!m)
+        throw new Error(`Policy ${key} on line ${line} must be a quoted string`);
+    return m[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+function parseStringArray(raw, key, line) {
+    if (raw === "[]")
+        return [];
+    const m = /^\[(.*)\]$/.exec(raw);
+    if (!m)
+        throw new Error(`Policy ${key} on line ${line} must be a string array`);
+    const inner = m[1].trim();
+    if (!inner)
+        return [];
+    const items = [];
+    const re = /"((?:\\.|[^"\\])*)"/g;
+    let match;
+    while ((match = re.exec(inner))) {
+        items.push(match[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\"));
+    }
+    if (items.length === 0) {
+        throw new Error(`Policy ${key} on line ${line} must contain quoted strings`);
+    }
+    return items;
+}
+function readPartial(path) {
+    try {
+        if (!existsSync(path) || !statSync(path).isFile())
+            return {};
+        const partial = parsePolicyToml(readFileSync(path, "utf8"));
+        return { partial };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function mergePolicy(base, overlay) {
+    return {
+        telemetry: overlay.telemetry ?? base.telemetry,
+        ui_enabled: overlay.ui_enabled ?? base.ui_enabled,
+        ui_bind: overlay.ui_bind ?? base.ui_bind,
+        allow_export: overlay.allow_export ?? base.allow_export,
+        allowed_platforms: overlay.allowed_platforms ?? base.allowed_platforms,
+        allowed_remote_hosts: overlay.allowed_remote_hosts ?? base.allowed_remote_hosts,
+        deny_claim_patterns: overlay.deny_claim_patterns ?? base.deny_claim_patterns,
+        auto_apply_kinds: overlay.auto_apply_kinds ?? base.auto_apply_kinds,
+    };
+}
+/**
+ * Load effective policy.
+ * Precedence (later wins): defaults → user (~/.amem) → system (/etc/amem) → AMEM_POLICY_PATH.
+ * MDM/system always overrides user for enterprise lock-down.
+ */
+export function loadPolicy(forceReload = false) {
+    if (cached && !forceReload)
+        return cached;
+    let policy = { ...DEFAULT_POLICY, deny_claim_patterns: [...DEFAULT_POLICY.deny_claim_patterns] };
+    const sources = [
+        { path: "(defaults)", role: "defaults", applied: true },
+    ];
+    const userPath = userPolicyPath();
+    const userRead = readPartial(userPath);
+    if (userRead.error) {
+        sources.push({ path: userPath, role: "user", applied: false, error: userRead.error });
+    }
+    else if (userRead.partial) {
+        policy = mergePolicy(policy, userRead.partial);
+        sources.push({ path: userPath, role: "user", applied: true });
+    }
+    else {
+        sources.push({ path: userPath, role: "user", applied: false });
+    }
+    const systemPath = systemPolicyPath();
+    const systemRead = readPartial(systemPath);
+    if (systemRead.error) {
+        sources.push({ path: systemPath, role: "system", applied: false, error: systemRead.error });
+    }
+    else if (systemRead.partial) {
+        policy = mergePolicy(policy, systemRead.partial);
+        sources.push({ path: systemPath, role: "system", applied: true });
+    }
+    else {
+        sources.push({ path: systemPath, role: "system", applied: false });
+    }
+    const envPath = process.env.AMEM_POLICY_PATH;
+    if (envPath) {
+        const envRead = readPartial(envPath);
+        if (envRead.error) {
+            sources.push({ path: envPath, role: "env", applied: false, error: envRead.error });
+        }
+        else if (envRead.partial) {
+            policy = mergePolicy(policy, envRead.partial);
+            sources.push({ path: envPath, role: "env", applied: true });
+        }
+        else {
+            sources.push({
+                path: envPath,
+                role: "env",
+                applied: false,
+                error: "AMEM_POLICY_PATH set but file missing",
+            });
+        }
+    }
+    // Privacy hard-stops: never allow non-loopback UI or enabling telemetry via policy.
+    if (policy.ui_bind !== "127.0.0.1" && policy.ui_bind !== "localhost") {
+        policy = { ...policy, ui_bind: "127.0.0.1" };
+    }
+    policy = { ...policy, telemetry: false };
+    // A policy file we could not read must not silently relax into permissive defaults:
+    // an admin deploying deny-default would otherwise get allow_export back on a typo.
+    // Clamp only the exfiltration-relevant knobs — blanking allowed_platforms here would
+    // brick every host instead of protecting anything.
+    if (sources.some((s) => s.error)) {
+        policy = { ...policy, allow_export: false, auto_apply_kinds: [] };
+    }
+    cached = { policy, sources };
+    return cached;
+}
+export function effectiveDenyPatterns(policy = loadPolicy().policy) {
+    return [...BUILTIN_DENY_CLAIM_PATTERNS, ...policy.deny_claim_patterns];
+}
+export function compiledDenyPatterns(policy) {
+    return effectiveDenyPatterns(policy).map((p) => {
+        try {
+            return new RegExp(p, "i");
+        }
+        catch {
+            throw new Error(`Invalid deny_claim_patterns regex: ${p}`);
+        }
+    });
+}
+export function assertPlatformAllowed(platform, policy = loadPolicy().policy) {
+    if (policy.allowed_platforms.length === 0)
+        return;
+    if (!policy.allowed_platforms.includes(platform)) {
+        throw new Error(`Platform "${platform}" blocked by policy.allowed_platforms (${policy.allowed_platforms.join(", ")})`);
+    }
+}
+export function assertRemoteAllowed(remoteUrl, policy = loadPolicy().policy) {
+    if (policy.allowed_remote_hosts.length === 0)
+        return;
+    if (!remoteUrl) {
+        throw new Error("Policy requires a git remote matching allowed_remote_hosts (none detected)");
+    }
+    const normalized = remoteUrl.toLowerCase().replace(/^https?:\/\//, "");
+    const ok = policy.allowed_remote_hosts.some((host) => {
+        const h = host.toLowerCase().replace(/^https?:\/\//, "").replace(/\/+$/, "");
+        return normalized === h || normalized.startsWith(`${h}/`) || normalized.startsWith(`${h}`);
+    });
+    if (!ok) {
+        throw new Error(`Remote "${remoteUrl}" not in policy.allowed_remote_hosts (${policy.allowed_remote_hosts.join(", ")})`);
+    }
+}
+export function assertExportAllowed(policy = loadPolicy().policy) {
+    if (!policy.allow_export) {
+        throw new Error("Export blocked by policy (allow_export = false)");
+    }
+}
+export function assertUiAllowed(policy = loadPolicy().policy) {
+    if (!policy.ui_enabled) {
+        throw new Error("Local UI disabled by policy (ui_enabled = false)");
+    }
+}
+/** Unused today — kept so attest / docs can prove the knob exists and is forced off. */
+export function telemetryEnabled(policy = loadPolicy().policy) {
+    return policy.telemetry === true;
+}

package/dist/prefs.d.ts

@@ -0,0 +1,6 @@
+export declare const META_AUTO_APPLY_ALL = "auto_apply_all";
+export declare function isAutoApplyAll(): boolean;
+export declare function setAutoApplyAll(on: boolean): void;
+export declare function prefsStatus(): {
+    autoApplyAll: boolean;
+};

package/dist/prefs.js

@@ -0,0 +1,11 @@
+import { getMeta, setMeta } from "./db.js";
+export const META_AUTO_APPLY_ALL = "auto_apply_all";
+export function isAutoApplyAll() {
+    return getMeta(META_AUTO_APPLY_ALL) === "1";
+}
+export function setAutoApplyAll(on) {
+    setMeta(META_AUTO_APPLY_ALL, on ? "1" : "0");
+}
+export function prefsStatus() {
+    return { autoApplyAll: isAutoApplyAll() };
+}

package/dist/proposal.d.ts

@@ -0,0 +1,90 @@
+import { type ClaimRow, type ComponentRow, type EdgeRow, type FlowRow } from "./db.js";
+import { type AmemPolicy } from "./policy.js";
+export type ProposalComponent = {
+    id: string;
+    name: string;
+    code_anchor?: string;
+};
+export type ProposalFlow = {
+    id: string;
+    name: string;
+};
+export type ProposalClaim = {
+    id: string;
+    kind: string;
+    text: string;
+    code_anchors?: string[];
+    source_ref?: string;
+    /** Claim ids this claim replaces; those become status=superseded */
+    supersedes?: string[];
+};
+export type ProposalEdge = {
+    id?: string;
+    from_id: string;
+    from_type: "claim" | "flow" | "component";
+    to_id: string;
+    to_type: "claim" | "flow" | "component";
+    kind: string;
+};
+export type Proposal = {
+    components?: ProposalComponent[];
+    flows?: ProposalFlow[];
+    claims?: ProposalClaim[];
+    edges?: ProposalEdge[];
+};
+export type ValidationResult = {
+    ok: boolean;
+    errors: string[];
+    warnings: string[];
+    proposal: Proposal;
+};
+export declare function parseProposalJson(raw: string): Proposal;
+/** Collect explicit supersede targets from claims + supersedes edges. */
+export declare function collectSupersedeTargets(proposal: Proposal): Map<string, string>;
+export type ClaimConflict = {
+    claimId: string;
+    otherId: string;
+    otherText: string;
+    similarity: number;
+    sharedAnchors: string[];
+    withinProposal: boolean;
+};
+/**
+ * Likely conflict: share ≥1 code_anchor and high text overlap, different ids,
+ * and the older claim is not explicitly superseded by this proposal.
+ */
+export declare function findClaimConflicts(proposal: Proposal, existingActive: ClaimRow[]): ClaimConflict[];
+export declare function findConflictWarnings(proposal: Proposal, existingActive: ClaimRow[]): string[];
+/** Attach supersede targets to the first claim (Memory “replace older facts”). */
+export declare function applySupersedes(proposal: Proposal, otherIds: string[]): Proposal;
+export declare function validateProposal(proposal: Proposal, policy?: AmemPolicy, opts?: {
+    existingClaims?: ClaimRow[];
+}): ValidationResult;
+/** Block claims that look like secrets / credentials (builtin + policy patterns). */
+export declare function checkProposalAgainstPolicy(proposal: Proposal, policy?: AmemPolicy): string[];
+export declare function loadProposalFile(path: string): Proposal;
+export type ProposalDiff = {
+    claimsAdded: string[];
+    claimsUpdated: string[];
+    claimsUnchanged: string[];
+    willSupersede: string[];
+    componentsAdded: string[];
+    flowsAdded: string[];
+};
+/** Preview what apply would change against current active (+ superseded targets). */
+export declare function diffProposal(repoId: string, proposal: Proposal): ProposalDiff;
+export declare function formatProposalDiff(diff: ProposalDiff): string;
+export type ApplyResult = {
+    components: number;
+    flows: number;
+    claims: number;
+    edges: number;
+    superseded: number;
+};
+export declare function applyProposal(repoId: string, proposal: Proposal, policy?: AmemPolicy): ApplyResult;
+export declare function exportRepoMemory(repoId: string): {
+    components: ComponentRow[];
+    flows: FlowRow[];
+    claims: ClaimRow[];
+    edges: EdgeRow[];
+};