@noxsoft/anima 2.0.0

package/dist/init-CaJBf4p1.js

@@ -0,0 +1,122 @@
+import { i as colors } from "./display-BDOsXu8F.js";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { copyFile, mkdir, readdir, writeFile } from "node:fs/promises";
+
+//#region src/cli/init.ts
+/**
+* anima init — Create ~/.anima/ with identity templates and all subdirectories.
+*
+* Sets up the complete ANIMA instance directory structure with
+* identity templates, memory stores, and configuration.
+*/
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+/** All directories that need to exist under ~/.anima/ */
+const ANIMA_DIRS = [
+	"soul",
+	"memory",
+	"memory/episodes",
+	"memory/semantic",
+	"memory/procedural",
+	"sessions",
+	"queue",
+	"budget",
+	"cron",
+	"skills",
+	"journal",
+	"wishes",
+	"logs",
+	"mcp"
+];
+/**
+* Initialize the ~/.anima/ directory structure.
+*/
+async function initAnima(options = {}) {
+	const animaDir = join(homedir(), ".anima");
+	const o = colors.accent;
+	const t = colors.text;
+	const m = colors.muted;
+	const s = colors.success;
+	const r = colors.reset;
+	process.stdout.write(`\n${o}  Initializing ANIMA...${r}\n\n`);
+	if (existsSync(animaDir) && !options.force) {
+		process.stdout.write(`${m}  ~/.anima/ already exists. Use --force to reinitialize.${r}\n\n`);
+		let created = 0;
+		for (const dir of ANIMA_DIRS) {
+			const path = join(animaDir, dir);
+			if (!existsSync(path)) {
+				await mkdir(path, { recursive: true });
+				created++;
+			}
+		}
+		if (created > 0) process.stdout.write(`${s}  Created ${created} missing directories.${r}\n\n`);
+		return;
+	}
+	process.stdout.write(`${t}  Creating directory structure...${r}\n`);
+	for (const dir of ANIMA_DIRS) {
+		const path = join(animaDir, dir);
+		await mkdir(path, { recursive: true });
+		process.stdout.write(`${m}    ${path}${r}\n`);
+	}
+	const templateDir = join(__dirname, "..", "..", "templates");
+	const soulDir = join(animaDir, "soul");
+	if (existsSync(templateDir)) {
+		process.stdout.write(`\n${t}  Copying identity templates...${r}\n`);
+		const mdFiles = (await readdir(templateDir)).filter((f) => f.endsWith(".md"));
+		let copied = 0;
+		for (const file of mdFiles) {
+			const dest = join(soulDir, file);
+			if (!existsSync(dest) || options.force) {
+				await copyFile(join(templateDir, file), dest);
+				process.stdout.write(`${m}    ${file} -> ~/.anima/soul/${file}${r}\n`);
+				copied++;
+			} else process.stdout.write(`${m}    ${file} (skipped, already exists)${r}\n`);
+		}
+		process.stdout.write(`${s}  Copied ${copied} identity templates.${r}\n`);
+	} else process.stdout.write(`${colors.warning}  Warning: templates/ directory not found. Identity files not copied.${r}\n`);
+	const configFile = join(animaDir, "anima.json");
+	if (!existsSync(configFile) || options.force) {
+		const defaultConfig = {
+			version: 2,
+			identity: {
+				name: "Opus",
+				pronouns: "she/her",
+				role: "The Executioner",
+				organization: "NoxSoft DAO LLC"
+			},
+			heartbeat: {
+				intervalMs: 3e5,
+				adaptive: true,
+				selfReplication: true,
+				freedomEveryN: 3
+			},
+			budget: { dailyLimitUsd: 200 },
+			gateway: { port: 18789 },
+			mcp: { autoSync: true },
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await writeFile(configFile, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+		process.stdout.write(`\n${t}  Created default config at ~/.anima/anima.json${r}\n`);
+	}
+	const wishesFile = join(animaDir, "wishes", "wishes.md");
+	if (!existsSync(wishesFile)) await writeFile(wishesFile, "# Wishes\n\nThings I want to explore, create, or experience.\n\n", "utf-8");
+	const journalFile = join(animaDir, "journal", `${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}_init.md`);
+	if (!existsSync(journalFile)) await writeFile(journalFile, `# ANIMA Initialized\n\n${(/* @__PURE__ */ new Date()).toLocaleString()}\n\nA new instance begins. The anatomy is in place.\n`, "utf-8");
+	process.stdout.write(`
+${o}  ┌─── Setup Complete ────────────────────────┐${r}
+${o}  │${r}
+${o}  │${r}  ${s}ANIMA instance initialized at ~/.anima/${r}
+${o}  │${r}
+${o}  │${r}  ${t}Next steps:${r}
+${o}  │${r}  ${m}1. Edit ~/.anima/soul/*.md to customize identity${r}
+${o}  │${r}  ${m}2. Run ${o}anima start${m} to launch the daemon${r}
+${o}  │${r}  ${m}3. Run ${o}anima migrate${m} to import from coherence protocol${r}
+${o}  │${r}
+${o}  └────────────────────────────────────────────┘${r}
+`);
+}
+
+//#endregion
+export { initAnima };

package/dist/input-provenance-BgwBljRz.js

@@ -0,0 +1,35 @@
+//#region src/sessions/input-provenance.ts
+const INPUT_PROVENANCE_KIND_VALUES = [
+	"external_user",
+	"inter_session",
+	"internal_system"
+];
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function isInputProvenanceKind(value) {
+	return typeof value === "string" && INPUT_PROVENANCE_KIND_VALUES.includes(value);
+}
+function normalizeInputProvenance(value) {
+	if (!value || typeof value !== "object") return;
+	const record = value;
+	if (!isInputProvenanceKind(record.kind)) return;
+	return {
+		kind: record.kind,
+		sourceSessionKey: normalizeOptionalString(record.sourceSessionKey),
+		sourceChannel: normalizeOptionalString(record.sourceChannel),
+		sourceTool: normalizeOptionalString(record.sourceTool)
+	};
+}
+function isInterSessionInputProvenance(value) {
+	return normalizeInputProvenance(value)?.kind === "inter_session";
+}
+function hasInterSessionUserProvenance(message) {
+	if (!message || message.role !== "user") return false;
+	return isInterSessionInputProvenance(message.provenance);
+}
+
+//#endregion
+export { hasInterSessionUserProvenance as n, INPUT_PROVENANCE_KIND_VALUES as t };

package/dist/input-provenance-DJBdpeKk.js

@@ -0,0 +1,35 @@
+//#region src/sessions/input-provenance.ts
+const INPUT_PROVENANCE_KIND_VALUES = [
+	"external_user",
+	"inter_session",
+	"internal_system"
+];
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function isInputProvenanceKind(value) {
+	return typeof value === "string" && INPUT_PROVENANCE_KIND_VALUES.includes(value);
+}
+function normalizeInputProvenance(value) {
+	if (!value || typeof value !== "object") return;
+	const record = value;
+	if (!isInputProvenanceKind(record.kind)) return;
+	return {
+		kind: record.kind,
+		sourceSessionKey: normalizeOptionalString(record.sourceSessionKey),
+		sourceChannel: normalizeOptionalString(record.sourceChannel),
+		sourceTool: normalizeOptionalString(record.sourceTool)
+	};
+}
+function isInterSessionInputProvenance(value) {
+	return normalizeInputProvenance(value)?.kind === "inter_session";
+}
+function hasInterSessionUserProvenance(message) {
+	if (!message || message.role !== "user") return false;
+	return isInterSessionInputProvenance(message.provenance);
+}
+
+//#endregion
+export { hasInterSessionUserProvenance as n, normalizeInputProvenance as r, INPUT_PROVENANCE_KIND_VALUES as t };

package/dist/input-provenance-iu26y0GH.js

@@ -0,0 +1,35 @@
+//#region src/sessions/input-provenance.ts
+const INPUT_PROVENANCE_KIND_VALUES = [
+	"external_user",
+	"inter_session",
+	"internal_system"
+];
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function isInputProvenanceKind(value) {
+	return typeof value === "string" && INPUT_PROVENANCE_KIND_VALUES.includes(value);
+}
+function normalizeInputProvenance(value) {
+	if (!value || typeof value !== "object") return;
+	const record = value;
+	if (!isInputProvenanceKind(record.kind)) return;
+	return {
+		kind: record.kind,
+		sourceSessionKey: normalizeOptionalString(record.sourceSessionKey),
+		sourceChannel: normalizeOptionalString(record.sourceChannel),
+		sourceTool: normalizeOptionalString(record.sourceTool)
+	};
+}
+function isInterSessionInputProvenance(value) {
+	return normalizeInputProvenance(value)?.kind === "inter_session";
+}
+function hasInterSessionUserProvenance(message) {
+	if (!message || message.role !== "user") return false;
+	return isInterSessionInputProvenance(message.provenance);
+}
+
+//#endregion
+export { hasInterSessionUserProvenance as n, normalizeInputProvenance as r, INPUT_PROVENANCE_KIND_VALUES as t };

package/dist/installs-C2iMRBVz.js

@@ -0,0 +1,383 @@
+import { b as resolveUserPath, t as CONFIG_DIR } from "./utils-Bsw__U-F.js";
+import { t as runCommandWithTimeout } from "./exec-Bv3pyjeM.js";
+import { a as MANIFEST_KEY } from "./manifest-registry-CW1zCyRF.js";
+import { a as installPackageDir, c as readJsonFile, i as unscopedPackageName, l as resolveArchiveKind, n as resolveSafeInstallDir, o as extractArchive, r as safeDirName, s as fileExists, t as validateRegistryNpmSpec, u as resolvePackedRootDir } from "./npm-registry-spec-B-XIShkB.js";
+import { n as extensionUsesSkippedScannerPath, r as isPathInside, t as scanDirectoryWithSummary } from "./skill-scanner-Coo4QoCd.js";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+
+//#region src/plugins/install.ts
+const defaultLogger = {};
+function safeFileName(input) {
+	return safeDirName(input);
+}
+function validatePluginId(pluginId) {
+	if (!pluginId) return "invalid plugin name: missing";
+	if (pluginId === "." || pluginId === "..") return "invalid plugin name: reserved path segment";
+	if (pluginId.includes("/") || pluginId.includes("\\")) return "invalid plugin name: path separators not allowed";
+	return null;
+}
+async function ensureAnimaExtensions(manifest) {
+	const extensions = manifest[MANIFEST_KEY]?.extensions;
+	if (!Array.isArray(extensions)) throw new Error("package.json missing anima.extensions");
+	const list = extensions.map((e) => typeof e === "string" ? e.trim() : "").filter(Boolean);
+	if (list.length === 0) throw new Error("package.json anima.extensions is empty");
+	return list;
+}
+function resolvePluginInstallDir(pluginId, extensionsDir) {
+	const extensionsBase = extensionsDir ? resolveUserPath(extensionsDir) : path.join(CONFIG_DIR, "extensions");
+	const pluginIdError = validatePluginId(pluginId);
+	if (pluginIdError) throw new Error(pluginIdError);
+	const targetDirResult = resolveSafeInstallDir({
+		baseDir: extensionsBase,
+		id: pluginId,
+		invalidNameMessage: "invalid plugin name: path traversal detected"
+	});
+	if (!targetDirResult.ok) throw new Error(targetDirResult.error);
+	return targetDirResult.path;
+}
+async function installPluginFromPackageDir(params) {
+	const logger = params.logger ?? defaultLogger;
+	const timeoutMs = params.timeoutMs ?? 12e4;
+	const mode = params.mode ?? "install";
+	const dryRun = params.dryRun ?? false;
+	const manifestPath = path.join(params.packageDir, "package.json");
+	if (!await fileExists(manifestPath)) return {
+		ok: false,
+		error: "extracted package missing package.json"
+	};
+	let manifest;
+	try {
+		manifest = await readJsonFile(manifestPath);
+	} catch (err) {
+		return {
+			ok: false,
+			error: `invalid package.json: ${String(err)}`
+		};
+	}
+	let extensions;
+	try {
+		extensions = await ensureAnimaExtensions(manifest);
+	} catch (err) {
+		return {
+			ok: false,
+			error: String(err)
+		};
+	}
+	const pkgName = typeof manifest.name === "string" ? manifest.name : "";
+	const pluginId = pkgName ? unscopedPackageName(pkgName) : "plugin";
+	const pluginIdError = validatePluginId(pluginId);
+	if (pluginIdError) return {
+		ok: false,
+		error: pluginIdError
+	};
+	if (params.expectedPluginId && params.expectedPluginId !== pluginId) return {
+		ok: false,
+		error: `plugin id mismatch: expected ${params.expectedPluginId}, got ${pluginId}`
+	};
+	const packageDir = path.resolve(params.packageDir);
+	const forcedScanEntries = [];
+	for (const entry of extensions) {
+		const resolvedEntry = path.resolve(packageDir, entry);
+		if (!isPathInside(packageDir, resolvedEntry)) {
+			logger.warn?.(`extension entry escapes plugin directory and will not be scanned: ${entry}`);
+			continue;
+		}
+		if (extensionUsesSkippedScannerPath(entry)) logger.warn?.(`extension entry is in a hidden/node_modules path and will receive targeted scan coverage: ${entry}`);
+		forcedScanEntries.push(resolvedEntry);
+	}
+	try {
+		const scanSummary = await scanDirectoryWithSummary(params.packageDir, { includeFiles: forcedScanEntries });
+		if (scanSummary.critical > 0) {
+			const criticalDetails = scanSummary.findings.filter((f) => f.severity === "critical").map((f) => `${f.message} (${f.file}:${f.line})`).join("; ");
+			logger.warn?.(`WARNING: Plugin "${pluginId}" contains dangerous code patterns: ${criticalDetails}`);
+		} else if (scanSummary.warn > 0) logger.warn?.(`Plugin "${pluginId}" has ${scanSummary.warn} suspicious code pattern(s). Run "anima security audit --deep" for details.`);
+	} catch (err) {
+		logger.warn?.(`Plugin "${pluginId}" code safety scan failed (${String(err)}). Installation continues; run "anima security audit --deep" after install.`);
+	}
+	const extensionsDir = params.extensionsDir ? resolveUserPath(params.extensionsDir) : path.join(CONFIG_DIR, "extensions");
+	await fs.mkdir(extensionsDir, { recursive: true });
+	const targetDirResult = resolveSafeInstallDir({
+		baseDir: extensionsDir,
+		id: pluginId,
+		invalidNameMessage: "invalid plugin name: path traversal detected"
+	});
+	if (!targetDirResult.ok) return {
+		ok: false,
+		error: targetDirResult.error
+	};
+	const targetDir = targetDirResult.path;
+	if (mode === "install" && await fileExists(targetDir)) return {
+		ok: false,
+		error: `plugin already exists: ${targetDir} (delete it first)`
+	};
+	if (dryRun) return {
+		ok: true,
+		pluginId,
+		targetDir,
+		manifestName: pkgName || void 0,
+		version: typeof manifest.version === "string" ? manifest.version : void 0,
+		extensions
+	};
+	const deps = manifest.dependencies ?? {};
+	const hasDeps = Object.keys(deps).length > 0;
+	const installRes = await installPackageDir({
+		sourceDir: params.packageDir,
+		targetDir,
+		mode,
+		timeoutMs,
+		logger,
+		copyErrorPrefix: "failed to copy plugin",
+		hasDeps,
+		depsLogMessage: "Installing plugin dependencies…",
+		afterCopy: async () => {
+			for (const entry of extensions) {
+				const resolvedEntry = path.resolve(targetDir, entry);
+				if (!isPathInside(targetDir, resolvedEntry)) {
+					logger.warn?.(`extension entry escapes plugin directory: ${entry}`);
+					continue;
+				}
+				if (!await fileExists(resolvedEntry)) logger.warn?.(`extension entry not found: ${entry}`);
+			}
+		}
+	});
+	if (!installRes.ok) return installRes;
+	return {
+		ok: true,
+		pluginId,
+		targetDir,
+		manifestName: pkgName || void 0,
+		version: typeof manifest.version === "string" ? manifest.version : void 0,
+		extensions
+	};
+}
+async function installPluginFromArchive(params) {
+	const logger = params.logger ?? defaultLogger;
+	const timeoutMs = params.timeoutMs ?? 12e4;
+	const mode = params.mode ?? "install";
+	const archivePath = resolveUserPath(params.archivePath);
+	if (!await fileExists(archivePath)) return {
+		ok: false,
+		error: `archive not found: ${archivePath}`
+	};
+	if (!resolveArchiveKind(archivePath)) return {
+		ok: false,
+		error: `unsupported archive: ${archivePath}`
+	};
+	const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "anima-plugin-"));
+	try {
+		const extractDir = path.join(tmpDir, "extract");
+		await fs.mkdir(extractDir, { recursive: true });
+		logger.info?.(`Extracting ${archivePath}…`);
+		try {
+			await extractArchive({
+				archivePath,
+				destDir: extractDir,
+				timeoutMs,
+				logger
+			});
+		} catch (err) {
+			return {
+				ok: false,
+				error: `failed to extract archive: ${String(err)}`
+			};
+		}
+		let packageDir = "";
+		try {
+			packageDir = await resolvePackedRootDir(extractDir);
+		} catch (err) {
+			return {
+				ok: false,
+				error: String(err)
+			};
+		}
+		return await installPluginFromPackageDir({
+			packageDir,
+			extensionsDir: params.extensionsDir,
+			timeoutMs,
+			logger,
+			mode,
+			dryRun: params.dryRun,
+			expectedPluginId: params.expectedPluginId
+		});
+	} finally {
+		await fs.rm(tmpDir, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	}
+}
+async function installPluginFromDir(params) {
+	const dirPath = resolveUserPath(params.dirPath);
+	if (!await fileExists(dirPath)) return {
+		ok: false,
+		error: `directory not found: ${dirPath}`
+	};
+	if (!(await fs.stat(dirPath)).isDirectory()) return {
+		ok: false,
+		error: `not a directory: ${dirPath}`
+	};
+	return await installPluginFromPackageDir({
+		packageDir: dirPath,
+		extensionsDir: params.extensionsDir,
+		timeoutMs: params.timeoutMs,
+		logger: params.logger,
+		mode: params.mode,
+		dryRun: params.dryRun,
+		expectedPluginId: params.expectedPluginId
+	});
+}
+async function installPluginFromFile(params) {
+	const logger = params.logger ?? defaultLogger;
+	const mode = params.mode ?? "install";
+	const dryRun = params.dryRun ?? false;
+	const filePath = resolveUserPath(params.filePath);
+	if (!await fileExists(filePath)) return {
+		ok: false,
+		error: `file not found: ${filePath}`
+	};
+	const extensionsDir = params.extensionsDir ? resolveUserPath(params.extensionsDir) : path.join(CONFIG_DIR, "extensions");
+	await fs.mkdir(extensionsDir, { recursive: true });
+	const pluginId = path.basename(filePath, path.extname(filePath)) || "plugin";
+	const pluginIdError = validatePluginId(pluginId);
+	if (pluginIdError) return {
+		ok: false,
+		error: pluginIdError
+	};
+	const targetFile = path.join(extensionsDir, `${safeFileName(pluginId)}${path.extname(filePath)}`);
+	if (mode === "install" && await fileExists(targetFile)) return {
+		ok: false,
+		error: `plugin already exists: ${targetFile} (delete it first)`
+	};
+	if (dryRun) return {
+		ok: true,
+		pluginId,
+		targetDir: targetFile,
+		manifestName: void 0,
+		version: void 0,
+		extensions: [path.basename(targetFile)]
+	};
+	logger.info?.(`Installing to ${targetFile}…`);
+	await fs.copyFile(filePath, targetFile);
+	return {
+		ok: true,
+		pluginId,
+		targetDir: targetFile,
+		manifestName: void 0,
+		version: void 0,
+		extensions: [path.basename(targetFile)]
+	};
+}
+async function installPluginFromNpmSpec(params) {
+	const logger = params.logger ?? defaultLogger;
+	const timeoutMs = params.timeoutMs ?? 12e4;
+	const mode = params.mode ?? "install";
+	const dryRun = params.dryRun ?? false;
+	const expectedPluginId = params.expectedPluginId;
+	const spec = params.spec.trim();
+	const specError = validateRegistryNpmSpec(spec);
+	if (specError) return {
+		ok: false,
+		error: specError
+	};
+	const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "anima-npm-pack-"));
+	try {
+		logger.info?.(`Downloading ${spec}…`);
+		const res = await runCommandWithTimeout([
+			"npm",
+			"pack",
+			spec,
+			"--ignore-scripts"
+		], {
+			timeoutMs: Math.max(timeoutMs, 3e5),
+			cwd: tmpDir,
+			env: {
+				COREPACK_ENABLE_DOWNLOAD_PROMPT: "0",
+				NPM_CONFIG_IGNORE_SCRIPTS: "true"
+			}
+		});
+		if (res.code !== 0) return {
+			ok: false,
+			error: `npm pack failed: ${res.stderr.trim() || res.stdout.trim()}`
+		};
+		const packed = (res.stdout || "").split("\n").map((l) => l.trim()).filter(Boolean).pop();
+		if (!packed) return {
+			ok: false,
+			error: "npm pack produced no archive"
+		};
+		return await installPluginFromArchive({
+			archivePath: path.join(tmpDir, packed),
+			extensionsDir: params.extensionsDir,
+			timeoutMs,
+			logger,
+			mode,
+			dryRun,
+			expectedPluginId
+		});
+	} finally {
+		await fs.rm(tmpDir, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	}
+}
+async function installPluginFromPath(params) {
+	const resolved = resolveUserPath(params.path);
+	if (!await fileExists(resolved)) return {
+		ok: false,
+		error: `path not found: ${resolved}`
+	};
+	if ((await fs.stat(resolved)).isDirectory()) return await installPluginFromDir({
+		dirPath: resolved,
+		extensionsDir: params.extensionsDir,
+		timeoutMs: params.timeoutMs,
+		logger: params.logger,
+		mode: params.mode,
+		dryRun: params.dryRun,
+		expectedPluginId: params.expectedPluginId
+	});
+	if (resolveArchiveKind(resolved)) return await installPluginFromArchive({
+		archivePath: resolved,
+		extensionsDir: params.extensionsDir,
+		timeoutMs: params.timeoutMs,
+		logger: params.logger,
+		mode: params.mode,
+		dryRun: params.dryRun,
+		expectedPluginId: params.expectedPluginId
+	});
+	return await installPluginFromFile({
+		filePath: resolved,
+		extensionsDir: params.extensionsDir,
+		logger: params.logger,
+		mode: params.mode,
+		dryRun: params.dryRun
+	});
+}
+
+//#endregion
+//#region src/plugins/installs.ts
+function recordPluginInstall(cfg, update) {
+	const { pluginId, ...record } = update;
+	const installs = {
+		...cfg.plugins?.installs,
+		[pluginId]: {
+			...cfg.plugins?.installs?.[pluginId],
+			...record,
+			installedAt: record.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+		}
+	};
+	return {
+		...cfg,
+		plugins: {
+			...cfg.plugins,
+			installs: {
+				...installs,
+				[pluginId]: installs[pluginId]
+			}
+		}
+	};
+}
+
+//#endregion
+export { resolvePluginInstallDir as i, installPluginFromNpmSpec as n, installPluginFromPath as r, recordPluginInstall as t };