@noxsoft/anima 2.0.2 → 2.0.4

package/dist/init-CaJBf4p1.js

@@ -1,122 +0,0 @@
-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/installs-C2iMRBVz.js

@@ -1,383 +0,0 @@
-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 };