@iamem/amem 0.1.0

package/dist/hygiene.js

@@ -0,0 +1,196 @@
+/**
+ * Local memory hygiene: decay unused facts, find near-duplicates, review inbox.
+ * Apply/schedule is Pro/IT only. Preview counts are free (soft paywall).
+ * Nothing is uploaded.
+ */
+import { getClaim, listClaims, listProposalDrafts, listRepos, listUsageEvents, setClaimStatus, } from "./db.js";
+import { FEATURE_HYGIENE, hasFeature, requireFeature } from "./license.js";
+import { applyProposal, applySupersedes } from "./proposal.js";
+import { tokenJaccard } from "./search.js";
+import { parseAnchors } from "./freshness.js";
+export const SOFT_PAYWALL_FACTS = 200;
+export const SOFT_PAYWALL_NOISE = 15;
+function usedClaimIds(repoId, days) {
+    const ids = new Set();
+    for (const event of listUsageEvents({ repoId, days })) {
+        try {
+            for (const id of JSON.parse(event.claim_ids || "[]")) {
+                if (id)
+                    ids.add(id);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return ids;
+}
+/** Shared heuristics — no license gate (used by free preview + Pro report). */
+function computeHygiene(repoId, unusedDays = 90) {
+    const claims = listClaims(repoId);
+    const used = usedClaimIds(repoId, unusedDays);
+    const cutoff = Date.now() - unusedDays * 86_400_000;
+    const stale = claims.filter((c) => {
+        if (Number(c.pinned || 0) > 0)
+            return false;
+        if (used.has(c.id))
+            return false;
+        const updated = Date.parse(c.updated_at);
+        return Number.isFinite(updated) && updated < cutoff;
+    });
+    const duplicates = [];
+    for (let i = 0; i < claims.length; i++) {
+        for (let j = i + 1; j < claims.length; j++) {
+            const a = claims[i];
+            const b = claims[j];
+            const sim = tokenJaccard(a.text, b.text);
+            if (sim < 0.72)
+                continue;
+            const aAnchors = new Set(parseAnchors(a.code_anchors));
+            const bAnchors = parseAnchors(b.code_anchors);
+            const share = bAnchors.some((p) => aAnchors.has(p));
+            if (!share && sim < 0.85)
+                continue;
+            const keep = Number(a.pinned || 0) >= Number(b.pinned || 0) && a.text.length >= b.text.length ? a : b;
+            const drop = keep.id === a.id ? b : a;
+            duplicates.push({ keepId: keep.id, dropId: drop.id, similarity: sim });
+        }
+    }
+    return {
+        stale,
+        duplicates: duplicates.slice(0, 40),
+        pendingDrafts: listProposalDrafts(repoId, { status: "pending" }).length,
+        active: claims.length,
+    };
+}
+/** Free: counts only for soft paywall / banners. Never applies changes. */
+export function hygienePreview(repoId, unusedDays = 90) {
+    const report = computeHygiene(repoId, unusedDays);
+    const staleCount = report.stale.length;
+    const duplicateCount = report.duplicates.length;
+    const removable = Math.min(report.active, staleCount + duplicateCount);
+    const afterCleanup = Math.max(0, report.active - removable);
+    const thresholdHit = report.active >= SOFT_PAYWALL_FACTS || staleCount + duplicateCount >= SOFT_PAYWALL_NOISE;
+    // Paid (hygiene unlocked) — never surface an unpaid soft-paywall signal.
+    const softPaywall = thresholdHit && !hasFeature(FEATURE_HYGIENE);
+    return {
+        active: report.active,
+        staleCount,
+        duplicateCount,
+        pendingDrafts: report.pendingDrafts,
+        afterCleanup,
+        softPaywall,
+    };
+}
+/** Aggregate preview across all tracked repos (for All memory scope). */
+export function hygienePreviewAll(unusedDays = 90) {
+    let active = 0;
+    let staleCount = 0;
+    let duplicateCount = 0;
+    let pendingDrafts = 0;
+    for (const repo of listRepos()) {
+        const p = hygienePreview(repo.id, unusedDays);
+        active += p.active;
+        staleCount += p.staleCount;
+        duplicateCount += p.duplicateCount;
+        pendingDrafts += p.pendingDrafts;
+    }
+    const removable = Math.min(active, staleCount + duplicateCount);
+    const afterCleanup = Math.max(0, active - removable);
+    const thresholdHit = active >= SOFT_PAYWALL_FACTS || staleCount + duplicateCount >= SOFT_PAYWALL_NOISE;
+    const softPaywall = thresholdHit && !hasFeature(FEATURE_HYGIENE);
+    return { active, staleCount, duplicateCount, pendingDrafts, afterCleanup, softPaywall };
+}
+export function hygieneReport(repoId, unusedDays = 90) {
+    requireFeature(FEATURE_HYGIENE, "Memory hygiene");
+    return computeHygiene(repoId, unusedDays);
+}
+export function decayStaleClaims(repoId, unusedDays = 90) {
+    requireFeature(FEATURE_HYGIENE, "Memory hygiene");
+    const decayed = [];
+    for (const claim of computeHygiene(repoId, unusedDays).stale) {
+        if (setClaimStatus(repoId, claim.id, "decayed"))
+            decayed.push(claim.id);
+    }
+    return { decayed };
+}
+export function mergeDuplicate(repoId, keepId, dropId) {
+    requireFeature(FEATURE_HYGIENE, "Memory hygiene");
+    const keep = getClaim(repoId, keepId);
+    const drop = getClaim(repoId, dropId);
+    if (!keep || !drop)
+        throw new Error("Both claims must exist to merge");
+    if (keep.id === drop.id)
+        throw new Error("Cannot merge a claim into itself");
+    const anchors = [...new Set([...parseAnchors(keep.code_anchors), ...parseAnchors(drop.code_anchors)])];
+    const proposal = applySupersedes({
+        claims: [
+            {
+                id: keep.id,
+                kind: keep.kind,
+                text: keep.text,
+                code_anchors: anchors,
+                supersedes: [drop.id],
+            },
+        ],
+    }, [drop.id]);
+    applyProposal(repoId, proposal);
+    return { keepId: keep.id, dropId: drop.id };
+}
+/** Decay unused + merge near-duplicates in one step (Pro/IT). */
+export function acceptSafeCleanups(repoId, unusedDays = 90) {
+    requireFeature(FEATURE_HYGIENE, "Memory hygiene");
+    const report = computeHygiene(repoId, unusedDays);
+    const decayed = [];
+    for (const claim of report.stale) {
+        if (setClaimStatus(repoId, claim.id, "decayed"))
+            decayed.push(claim.id);
+    }
+    const decayedSet = new Set(decayed);
+    const gone = new Set(decayed);
+    const merged = [];
+    const ordered = [...report.duplicates].sort((a, b) => b.similarity - a.similarity);
+    for (const d of ordered) {
+        if (gone.has(d.keepId) || gone.has(d.dropId))
+            continue;
+        if (decayedSet.has(d.keepId) || decayedSet.has(d.dropId))
+            continue;
+        try {
+            mergeDuplicate(repoId, d.keepId, d.dropId);
+            merged.push(d);
+            gone.add(d.dropId);
+        }
+        catch {
+            // claim may have been removed mid-loop
+        }
+    }
+    return { decayed, merged };
+}
+/** Scheduled job: clean every tracked repo when licensed. */
+export function runScheduledHygiene(unusedDays = 90) {
+    if (!hasFeature(FEATURE_HYGIENE)) {
+        return { skipped: true, reason: "Pro/IT license required for hygiene", repos: [] };
+    }
+    const repos = [];
+    for (const repo of listRepos()) {
+        try {
+            const result = acceptSafeCleanups(repo.id, unusedDays);
+            repos.push({
+                repoId: repo.id,
+                name: repo.repo_name,
+                decayed: result.decayed.length,
+                merged: result.merged.length,
+            });
+        }
+        catch (error) {
+            repos.push({
+                repoId: repo.id,
+                name: repo.repo_name,
+                decayed: 0,
+                merged: 0,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { repos };
+}

package/dist/install/claude.d.ts

@@ -0,0 +1,6 @@
+export type InstallResult = {
+    skills: string[];
+    settingsPath?: string;
+};
+export declare function installClaude(_repoRoot: string): InstallResult;
+export declare function claudeInstallHealth(): string[];

package/dist/install/claude.js

@@ -0,0 +1,69 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { copyBundledSkills, readJsonObject, resolveAmemBin, writeJson } from "./skills.js";
+function claudeHome() {
+    return process.env.CLAUDE_HOME ?? join(homedir(), ".claude");
+}
+function mergeClaudeHooks(settingsPath) {
+    const amem = resolveAmemBin();
+    const settings = readJsonObject(settingsPath);
+    const hooks = settings.hooks ?? {};
+    const track = {
+        type: "command",
+        command: `${amem} session touch --platform claude`,
+    };
+    const fullHook = {
+        type: "command",
+        command: `${amem} hook`,
+    };
+    const ensureEvent = (name, entry) => {
+        const existing = Array.isArray(hooks[name]) ? hooks[name] : [];
+        const filtered = existing.filter((row) => {
+            if (!row || typeof row !== "object")
+                return true;
+            const matcher = row;
+            const cmds = matcher.hooks ?? [];
+            return !cmds.some((h) => (h.command ?? "").includes("amem session touch") ||
+                (h.command ?? "").includes("amem hook"));
+        });
+        hooks[name] = [
+            ...filtered,
+            {
+                matcher: "",
+                hooks: [entry],
+            },
+        ];
+    };
+    // Full hook pipeline (inject + notes + drafts). Keep Stop on the same path as Cursor.
+    ensureEvent("UserPromptSubmit", fullHook);
+    ensureEvent("Stop", fullHook);
+    // Lightweight session touch remains useful if UserPromptSubmit payload is sparse
+    ensureEvent("Notification", track);
+    settings.hooks = hooks;
+    writeJson(settingsPath, settings);
+    return settingsPath;
+}
+export function installClaude(_repoRoot) {
+    const skills = copyBundledSkills(join(claudeHome(), "skills"));
+    const settingsPath = join(claudeHome(), "settings.json");
+    mergeClaudeHooks(settingsPath);
+    return { skills, settingsPath };
+}
+export function claudeInstallHealth() {
+    const issues = [];
+    const skill = join(claudeHome(), "skills", "amem-bootstrap", "SKILL.md");
+    if (!existsSync(skill))
+        issues.push(`Missing Claude skill: ${skill}`);
+    const settingsPath = join(claudeHome(), "settings.json");
+    if (!existsSync(settingsPath)) {
+        issues.push(`Missing Claude settings: ${settingsPath}`);
+    }
+    else {
+        const raw = JSON.stringify(readJsonObject(settingsPath));
+        if (!raw.includes("amem hook") && !/cli\.js\s+hook/.test(raw)) {
+            issues.push("Claude settings.json does not call `amem hook` — re-run amem init --platform claude");
+        }
+    }
+    return issues;
+}

package/dist/install/cursor.d.ts

@@ -0,0 +1,7 @@
+export type InstallResult = {
+    skills: string[];
+    rulePath?: string;
+    hooksPath?: string;
+};
+export declare function installCursor(repoRoot: string): InstallResult;
+export declare function cursorInstallHealth(repoRoot: string): string[];

package/dist/install/cursor.js

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { copyBundledSkills, readJsonObject, resolveAmemBin, templatePath, writeJson, } from "./skills.js";
+import { readFileSync } from "node:fs";
+function cursorHome() {
+    return process.env.CURSOR_HOME ?? join(homedir(), ".cursor");
+}
+function writeCursorRule(repoRoot) {
+    const rulesDir = join(repoRoot, ".cursor", "rules");
+    mkdirSync(rulesDir, { recursive: true });
+    let rulePath = join(rulesDir, "amem.mdc");
+    if (existsSync(rulePath)) {
+        const existing = readFileSync(rulePath, "utf8");
+        if (!existing.includes("Generated by amem")) {
+            rulePath = join(rulesDir, "amem-1.mdc");
+        }
+    }
+    const template = readFileSync(templatePath("cursor-rule.mdc"), "utf8");
+    writeFileSync(rulePath, template, "utf8");
+    return rulePath;
+}
+function writeCursorHooks() {
+    const hooksPath = join(cursorHome(), "hooks.json");
+    const amem = resolveAmemBin();
+    const existing = readJsonObject(hooksPath);
+    existing.version = 1;
+    const hooks = existing.hooks ?? {};
+    const hookCmd = `${amem} hook`;
+    const entry = {
+        command: hookCmd,
+        description: "amem: inject and store local memory (Generated by amem)",
+    };
+    const filterAmem = (entries) => entries.filter((e) => {
+        if (!e || typeof e !== "object")
+            return true;
+        const desc = e.description ?? "";
+        const command = e.command ?? "";
+        return !desc.includes("Generated by amem") && !command.includes("amem session touch") && !command.includes("amem hook");
+    });
+    for (const event of ["sessionStart", "beforeSubmitPrompt", "afterAgentResponse", "stop", "sessionEnd"]) {
+        const current = Array.isArray(hooks[event]) ? hooks[event] : [];
+        hooks[event] = [...filterAmem(current), entry];
+    }
+    existing.hooks = hooks;
+    writeJson(hooksPath, existing);
+    return hooksPath;
+}
+export function installCursor(repoRoot) {
+    const skills = copyBundledSkills(join(cursorHome(), "skills"));
+    const rulePath = writeCursorRule(repoRoot);
+    const hooksPath = writeCursorHooks();
+    return { skills, rulePath, hooksPath };
+}
+export function cursorInstallHealth(repoRoot) {
+    const issues = [];
+    const skill = join(cursorHome(), "skills", "amem-bootstrap", "SKILL.md");
+    if (!existsSync(skill))
+        issues.push(`Missing Cursor skill: ${skill}`);
+    const rule = join(repoRoot, ".cursor", "rules", "amem.mdc");
+    const ruleAlt = join(repoRoot, ".cursor", "rules", "amem-1.mdc");
+    if (!existsSync(rule) && !existsSync(ruleAlt)) {
+        issues.push(`Missing Cursor rule under ${join(repoRoot, ".cursor", "rules")}`);
+    }
+    const hooksPath = join(cursorHome(), "hooks.json");
+    if (!existsSync(hooksPath)) {
+        issues.push(`Missing Cursor hooks: ${hooksPath}`);
+    }
+    else {
+        const raw = readFileSync(hooksPath, "utf8");
+        // PATH install: `…/amem hook`; linked-from-source: `node …/cli.js hook`
+        const hasHook = raw.includes("amem hook") ||
+            /cli\.js\s+hook/.test(raw) ||
+            raw.includes("Generated by amem");
+        if (!hasHook) {
+            issues.push("Cursor hooks.json does not call `amem hook` — re-run amem init --platform cursor");
+        }
+    }
+    return issues;
+}

package/dist/install/hosts.d.ts

@@ -0,0 +1,21 @@
+export type HostInstallResult = {
+    host: string;
+    paths: string[];
+    notes: string[];
+};
+/** Windsurf: MCP in ~/.codeium/windsurf/mcp_config.json (common layout). */
+export declare function installWindsurf(workspace?: string): HostInstallResult;
+/** Continue.dev: ~/.continue/config.json plus mcpServers/amem.yaml (1.x HTTP). */
+export declare function installContinue(workspace?: string): HostInstallResult;
+/** Aider: drop a small CONVENTIONS hint + shell helper (Aider has no MCP). */
+export declare function installAider(repoRoot: string): HostInstallResult;
+/** Zed: settings.json context_servers / mcp style. */
+export declare function installZed(workspace?: string): HostInstallResult;
+export declare function continueInstallHealth(): string[];
+export declare function zedInstallHealth(): string[];
+export declare function windsurfInstallHealth(): string[];
+export declare function hostInstallHealth(host: string): string[];
+export declare function installHost(host: string, opts?: {
+    repoRoot?: string;
+    workspace?: string;
+}): HostInstallResult;

package/dist/install/hosts.js

@@ -0,0 +1,186 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mcpClientConfig } from "../mcp.js";
+import { resolveAmemBin, writeJson, readJsonObject } from "./skills.js";
+function ensureDir(path) {
+    mkdirSync(path, { recursive: true });
+}
+/** Windsurf: MCP in ~/.codeium/windsurf/mcp_config.json (common layout). */
+export function installWindsurf(workspace = "personal") {
+    const dir = join(homedir(), ".codeium", "windsurf");
+    ensureDir(dir);
+    const path = join(dir, "mcp_config.json");
+    const existing = readJsonObject(path);
+    const servers = existing.mcpServers ?? {};
+    const cfg = mcpClientConfig(workspace);
+    servers.amem = {
+        url: cfg.http.url,
+    };
+    writeJson(path, { ...existing, mcpServers: servers });
+    return {
+        host: "windsurf",
+        paths: [path],
+        notes: [`MCP server amem → ${cfg.http.url}. Keep amem ui running. Restart Windsurf if needed.`],
+    };
+}
+function continueMcpYamlPath() {
+    return join(homedir(), ".continue", "mcpServers", "amem.yaml");
+}
+/** Continue.dev: ~/.continue/config.json plus mcpServers/amem.yaml (1.x HTTP). */
+export function installContinue(workspace = "personal") {
+    const dir = join(homedir(), ".continue");
+    ensureDir(dir);
+    ensureDir(join(dir, "mcpServers"));
+    const path = join(dir, "config.json");
+    const existing = existsSync(path) ? readJsonObject(path) : { models: [] };
+    const experimental = existing.experimental ?? {};
+    const modelContext = experimental.modelContextProtocolServers ?? [];
+    const filtered = modelContext.filter((e) => {
+        if (!e || typeof e !== "object")
+            return true;
+        const name = e.name;
+        return name !== "amem";
+    });
+    const cfg = mcpClientConfig(workspace);
+    filtered.push({
+        name: "amem",
+        url: cfg.http.url,
+    });
+    experimental.modelContextProtocolServers = filtered;
+    writeJson(path, { ...existing, experimental });
+    const yaml = continueMcpYamlPath();
+    writeFileSync(yaml, `name: amem
+type: sse
+url: ${cfg.http.url}
+`, "utf8");
+    return {
+        host: "continue",
+        paths: [path, yaml],
+        notes: [
+            `Continue MCP amem → ${cfg.http.url}. Keep amem ui running.`,
+            `Drop-in: ${yaml}`,
+        ],
+    };
+}
+/** Aider: drop a small CONVENTIONS hint + shell helper (Aider has no MCP). */
+export function installAider(repoRoot) {
+    const path = join(repoRoot, ".aider.amem.md");
+    const body = `# amem + Aider
+
+Before large exploration, run:
+
+\`\`\`bash
+amem context "\${user question}" 
+\`\`\`
+
+After durable discoveries:
+
+\`\`\`bash
+amem remember "…" --anchor path/to/file
+\`\`\`
+
+Memory stays in ~/.amem (personal, local).
+`;
+    writeFileSync(path, body, "utf8");
+    return {
+        host: "aider",
+        paths: [path],
+        notes: [
+            "Aider has no MCP — added .aider.amem.md with CLI hints. Consider: aider --read .aider.amem.md",
+        ],
+    };
+}
+/** Zed: settings.json context_servers / mcp style. */
+export function installZed(workspace = "personal") {
+    const dir = process.platform === "darwin"
+        ? join(homedir(), "Library", "Application Support", "Zed")
+        : join(homedir(), ".config", "zed");
+    ensureDir(dir);
+    const path = join(dir, "settings.json");
+    const existing = existsSync(path) ? readJsonObject(path) : {};
+    const servers = existing.context_servers ?? {};
+    const amem = resolveAmemBin();
+    const cfg = mcpClientConfig(workspace);
+    servers.amem = {
+        source: "custom",
+        command: amem.split(/\s+/)[0],
+        args: amem.split(/\s+/).slice(1).concat(["mcp", "--workspace", workspace]),
+        env: {},
+        url: cfg.http.url,
+    };
+    writeJson(path, {
+        ...existing,
+        context_servers: servers,
+        amem_http_mcp: cfg.http,
+    });
+    return {
+        host: "zed",
+        paths: [path],
+        notes: [
+            `Zed context_servers.amem → ${cfg.http.url} (HTTP while amem ui runs; command is the fallback).`,
+        ],
+    };
+}
+function fileMentionsAmem(path) {
+    if (!existsSync(path))
+        return false;
+    try {
+        return readFileSync(path, "utf8").includes("amem");
+    }
+    catch {
+        return false;
+    }
+}
+export function continueInstallHealth() {
+    const json = join(homedir(), ".continue", "config.json");
+    const yaml = continueMcpYamlPath();
+    if (!fileMentionsAmem(json) && !fileMentionsAmem(yaml)) {
+        return ["Continue has no amem MCP entry — run amem init --platform continue"];
+    }
+    return [];
+}
+export function zedInstallHealth() {
+    const dir = process.platform === "darwin"
+        ? join(homedir(), "Library", "Application Support", "Zed")
+        : join(homedir(), ".config", "zed");
+    const path = join(dir, "settings.json");
+    if (!fileMentionsAmem(path)) {
+        return ["Zed settings have no amem context server — run amem init --platform zed"];
+    }
+    return [];
+}
+export function windsurfInstallHealth() {
+    const path = join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+    if (!fileMentionsAmem(path)) {
+        return ["Windsurf has no amem MCP entry — run amem init --platform windsurf"];
+    }
+    return [];
+}
+export function hostInstallHealth(host) {
+    switch (host) {
+        case "continue":
+            return continueInstallHealth();
+        case "zed":
+            return zedInstallHealth();
+        case "windsurf":
+            return windsurfInstallHealth();
+        default:
+            return [];
+    }
+}
+export function installHost(host, opts = {}) {
+    const ws = opts.workspace || "personal";
+    switch (host) {
+        case "windsurf":
+            return installWindsurf(ws);
+        case "continue":
+            return installContinue(ws);
+        case "aider":
+            return installAider(opts.repoRoot || process.cwd());
+        case "zed":
+            return installZed(ws);
+        default:
+            throw new Error(`No thin installer for host: ${host}`);
+    }
+}

package/dist/install/skills.d.ts

@@ -0,0 +1,8 @@
+export declare function getPackageRoot(): string;
+export declare function skillsSourceDir(): string;
+export declare function templatePath(...parts: string[]): string;
+export declare function copyBundledSkills(targetSkillsDir: string): string[];
+export declare function readJsonObject(path: string): Record<string, unknown>;
+export declare function writeJson(path: string, value: unknown): void;
+export declare function resolveAmemBin(): string;
+export declare function resolveAmemProgramArgs(...extra: string[]): string[];

package/dist/install/skills.js

@@ -0,0 +1,67 @@
+import { execFileSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+// dist/install/skills.js -> package root is ../..
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+export function getPackageRoot() {
+    return packageRoot;
+}
+export function skillsSourceDir() {
+    return join(packageRoot, "skills");
+}
+export function templatePath(...parts) {
+    return join(packageRoot, "templates", ...parts);
+}
+export function copyBundledSkills(targetSkillsDir) {
+    mkdirSync(targetSkillsDir, { recursive: true });
+    const source = skillsSourceDir();
+    const installed = [];
+    for (const name of ["amem-bootstrap", "amem-update-working-memory"]) {
+        const from = join(source, name);
+        const to = join(targetSkillsDir, name);
+        if (!existsSync(from)) {
+            throw new Error(`Missing bundled skill: ${from}`);
+        }
+        cpSync(from, to, { recursive: true });
+        installed.push(to);
+    }
+    return installed;
+}
+export function readJsonObject(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // replace corrupt file carefully by returning empty and letting caller rewrite
+    }
+    return {};
+}
+export function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+export function resolveAmemBin() {
+    const args = resolveAmemProgramArgs();
+    return args.length === 1 ? args[0] : args.map((a) => (a.includes(" ") ? JSON.stringify(a) : a)).join(" ");
+}
+export function resolveAmemProgramArgs(...extra) {
+    try {
+        const found = execFileSync("which", ["amem"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (found)
+            return [found, ...extra];
+    }
+    catch {
+        // fall through
+    }
+    const cli = join(getPackageRoot(), "dist", "cli.js");
+    return [process.execPath, cli, ...extra];
+}

package/dist/it-pack.d.ts

@@ -0,0 +1,20 @@
+export type SbomComponent = {
+    name: string;
+    version: string;
+    type: "application" | "library";
+};
+export type Sbom = {
+    bomFormat: "CycloneDX";
+    specVersion: "1.5";
+    serialNumber: string;
+    metadata: {
+        timestamp: string;
+        component: SbomComponent;
+    };
+    components: SbomComponent[];
+};
+export declare function buildSbom(): Sbom;
+export declare function writeItPack(outDir: string): {
+    dir: string;
+    files: string[];
+};