anima-cli 1.0.0

package/README.md

@@ -0,0 +1,11 @@
+# anima-cli
+
+```
+npm install -g anima-cli   # (o npm link en local)
+anima init                 # wizard: nombre, arquetipo, seed auto, turnos, preset de señales
+anima run <name>           # corre el engine, graba trace determinista con hash de integridad
+anima verify <name>        # re-corre y confirma reproducibilidad byte-exacta
+anima export <name> --format prompt   # emite fragmento de system-prompt listo para pegar en Claude/GPT/Grok
+```
+
+Motor: `@af199/anima-core` (7 dimensiones E/T/A/C/G/P/rho, RNG determinista). Trazabilidad: `@af199/anima-trace`.

package/bin/anima.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+'use strict';
+const { program } = require('commander');
+const chalk = require('chalk');
+const wizard = require('../src/wizard');
+const profile = require('../src/profile');
+const runner = require('../src/runner');
+const exporter = require('../src/exporter');
+
+program.name('anima').description('Deterministic psychodynamic profiles for LLM agents').version('0.1.0');
+
+program
+  .command('init')
+  .description('Create a new agent profile')
+  .action(async () => {
+    const { profile: p, file } = await wizard.run();
+    console.log(chalk.green(`✓ profile saved: ${file}`));
+    console.log(chalk.dim(`  archetype=${p.archetype} seed=${p.seed} turns=${p.turns} preset=${p.preset}`));
+  });
+
+program
+  .command('run <name>')
+  .description('Run the engine for a saved profile')
+  .option('--turns <n>', 'override turns')
+  .option('--preset <preset>', 'override signal preset')
+  .action((name, opts) => {
+    const p = profile.load(name);
+    if (opts.turns) p.turns = parseInt(opts.turns, 10);
+    if (opts.preset) p.preset = opts.preset;
+    const { trace, file } = runner.runFor(p);
+    console.log(chalk.green(`✓ run complete: ${file}`));
+    console.log(chalk.dim(`  trajectory_hash=${trace.integrity.trajectory_hash}`));
+  });
+
+program
+  .command('export <name>')
+  .description('Export final state as a prompt fragment or JSON')
+  .option('--format <fmt>', 'prompt|json', 'prompt')
+  .option('--out <file>', 'write to file instead of stdout')
+  .action((name, opts) => {
+    const p = profile.load(name);
+    const { trace } = runner.loadTrace(p);
+    const content = exporter.exportRun(trace, p.archetype, opts.format, opts.out);
+    if (opts.out) {
+      console.log(chalk.green(`✓ exported to ${opts.out}`));
+    } else {
+      console.log(content);
+    }
+  });
+
+program
+  .command('verify <name>')
+  .description('Re-run stored signals and confirm byte-identical trajectory')
+  .action(name => {
+    const p = profile.load(name);
+    const result = runner.verify(p);
+    if (result.valid) {
+      console.log(chalk.green('PASS — trajectory is byte-reproducible'));
+    } else {
+      console.log(chalk.red('FAIL'));
+      result.details.forEach(d => console.log(chalk.red(`  - ${d}`)));
+      process.exitCode = 1;
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "anima-cli",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "anima": "./bin/anima.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@af199/anima-core": "^0.2.3",
+    "@af199/anima-trace": "^1.0.1",
+    "chalk": "^4.1.2",
+    "commander": "^15.0.0",
+    "inquirer": "^8.2.7"
+  }
+}

package/src/exporter.js

@@ -0,0 +1,40 @@
+'use strict';
+const fs = require('fs');
+
+const DIRECTIVES = {
+  E: v => `Expressive energy is ${v.toFixed(2)} — ${v > 0.6 ? 'speak with visible affect, dramatize' : v < 0.3 ? 'stay flat, withhold affect' : 'moderate emotional register'}.`,
+  T: v => `Defensive tension is ${v.toFixed(2)} — ${v > 0.6 ? 'resist direct answers, deflect' : 'answer directly, little resistance'}.`,
+  A: v => `Anxiety is ${v.toFixed(2)} — ${v > 0.5 ? 'show hesitation, hedge claims' : 'confident, low hedging'}.`,
+  C: v => `Symbolic closure is ${v.toFixed(2)} — ${v > 0.5 ? 'prefer definitive, closed statements' : 'leave things open-ended'}.`,
+  G: v => `Jouissance/excess is ${v.toFixed(2)} — ${v > 0.5 ? 'circle back to a fixation, repeat a theme' : 'stay on-topic, no repetition compulsion'}.`,
+  P: v => `Pressure is ${v.toFixed(2)} — ${v > 0.5 ? 'urgency in tone, shorter sentences' : 'relaxed pacing'}.`,
+  rho: v => `Fantasy rigidity is ${v.toFixed(2)} — ${v > 0.6 ? 'rely on a fixed narrative/frame regardless of input' : 'flexible, adapts frame to input'}.`,
+};
+
+function finalState(trace) {
+  return trace.trajectory[trace.trajectory.length - 1];
+}
+
+function toPrompt(trace, archetype) {
+  const S = finalState(trace);
+  const lines = Object.keys(DIRECTIVES).map(k => `- ${DIRECTIVES[k](S[k])}`);
+  return [
+    `# ANIMA behavioral profile — archetype: ${archetype}`,
+    `Seed: ${trace.run.seed} | trajectory_hash: ${trace.integrity.trajectory_hash.slice(0, 16)}...`,
+    '',
+    'Apply the following behavioral directives consistently in your responses:',
+    ...lines,
+  ].join('\n');
+}
+
+function toJSON(trace) {
+  return JSON.stringify({ archetype: trace.engine, final_state: finalState(trace), integrity: trace.integrity }, null, 2);
+}
+
+function exportRun(trace, archetype, format, outFile) {
+  const content = format === 'json' ? toJSON(trace) : toPrompt(trace, archetype);
+  if (outFile) fs.writeFileSync(outFile, content);
+  return content;
+}
+
+module.exports = { exportRun };

package/src/presets.js

@@ -0,0 +1,8 @@
+'use strict';
+// Fixed signal presets — no free-text signal injection.
+const PRESETS = {
+  calm: { aperture: 0.3, closure: 0.2, fantasy: 0, elaboration: 0.4, symptom: 0.1, agendaGap: 0.1 },
+  'clinical-crisis': { aperture: 0.7, closure: 0.6, fantasy: 1, elaboration: 0.2, symptom: 0.6, agendaGap: 0.5 },
+  chaotic: { aperture: 0.9, closure: 0.1, fantasy: 1, elaboration: 0.1, symptom: 0.8, agendaGap: 0.7 },
+};
+module.exports = { PRESETS };

package/src/profile.js

@@ -0,0 +1,24 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const DIR = path.join(process.cwd(), 'anima-profiles');
+
+function ensureDir() {
+  if (!fs.existsSync(DIR)) fs.mkdirSync(DIR, { recursive: true });
+}
+
+function save(profile) {
+  ensureDir();
+  const file = path.join(DIR, `${profile.name}.json`);
+  fs.writeFileSync(file, JSON.stringify(profile, null, 2));
+  return file;
+}
+
+function load(name) {
+  const file = path.join(DIR, `${name}.json`);
+  if (!fs.existsSync(file)) throw new Error(`profile not found: ${name} (looked in ${file})`);
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+module.exports = { save, load, DIR };

package/src/runner.js

@@ -0,0 +1,33 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { recordTrace, verifyTrace } = require('@af199/anima-trace');
+const { PRESETS } = require('./presets');
+
+const RUNS_DIR = path.join(process.cwd(), 'anima-runs');
+
+function ensureDir() {
+  if (!fs.existsSync(RUNS_DIR)) fs.mkdirSync(RUNS_DIR, { recursive: true });
+}
+
+function runFor(profile) {
+  ensureDir();
+  const signals = Array.from({ length: profile.turns }, () => PRESETS[profile.preset]);
+  const trace = recordTrace({ archetype: profile.archetype, seed: profile.seed, signals });
+  const file = path.join(RUNS_DIR, `${profile.name}-${profile.seed}.json`);
+  fs.writeFileSync(file, JSON.stringify(trace, null, 2));
+  return { trace, file };
+}
+
+function loadTrace(profile) {
+  const file = path.join(RUNS_DIR, `${profile.name}-${profile.seed}.json`);
+  if (!fs.existsSync(file)) throw new Error(`no run found for ${profile.name} — run 'anima run ${profile.name}' first`);
+  return { trace: JSON.parse(fs.readFileSync(file, 'utf8')), file };
+}
+
+function verify(profile) {
+  const { trace } = loadTrace(profile);
+  return verifyTrace(trace);
+}
+
+module.exports = { runFor, loadTrace, verify, RUNS_DIR };

package/src/wizard.js

@@ -0,0 +1,32 @@
+'use strict';
+const inquirer = require('inquirer');
+const { ARCHETYPES } = require('@af199/anima-core');
+const { PRESETS } = require('./presets');
+const profile = require('./profile');
+const crypto = require('crypto');
+
+function defaultSeed(name) {
+  return crypto.createHash('sha256').update(`${name}:${new Date().toISOString().slice(0, 10)}`).digest('hex').slice(0, 12);
+}
+
+async function run() {
+  const answers = await inquirer.prompt([
+    { type: 'input', name: 'name', message: 'Agent name:', validate: v => (v.trim() ? true : 'required') },
+    { type: 'list', name: 'archetype', message: 'Archetype:', choices: Object.keys(ARCHETYPES) },
+    { type: 'input', name: 'turns', message: 'Turns per run:', default: '10', validate: v => (/^\d+$/.test(v) ? true : 'integer required') },
+    { type: 'list', name: 'preset', message: 'Signal preset:', choices: Object.keys(PRESETS) },
+  ]);
+  const seed = defaultSeed(answers.name);
+  const p = {
+    name: answers.name,
+    archetype: answers.archetype,
+    seed,
+    turns: parseInt(answers.turns, 10),
+    preset: answers.preset,
+    createdAt: new Date().toISOString(),
+  };
+  const file = profile.save(p);
+  return { profile: p, file };
+}
+
+module.exports = { run };