@auxiora/personality 1.0.0

package/src/modes/mode-loader.ts

@@ -0,0 +1,105 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { MODE_IDS, type ModeId, type ModeTemplate, type ModeSignal } from './types.js';
+
+export class ModeLoader {
+  private builtInDir: string;
+  private userDir: string;
+  private cache: Map<ModeId, ModeTemplate> = new Map();
+
+  constructor(builtInDir: string, userDir: string) {
+    this.builtInDir = builtInDir;
+    this.userDir = userDir;
+  }
+
+  async loadAll(): Promise<Map<ModeId, ModeTemplate>> {
+    this.cache.clear();
+
+    // Load built-in modes first
+    await this.loadFromDir(this.builtInDir);
+
+    // User modes override built-ins
+    await this.loadFromDir(this.userDir);
+
+    return this.cache;
+  }
+
+  get(id: ModeId): ModeTemplate | undefined {
+    return this.cache.get(id);
+  }
+
+  getAll(): Map<ModeId, ModeTemplate> {
+    return this.cache;
+  }
+
+  async reload(): Promise<Map<ModeId, ModeTemplate>> {
+    return this.loadAll();
+  }
+
+  private async loadFromDir(dir: string): Promise<void> {
+    let entries: string[];
+    try {
+      entries = await fs.readdir(dir);
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.endsWith('.md')) continue;
+      const id = path.basename(entry, '.md');
+      if (!MODE_IDS.includes(id as ModeId)) continue;
+
+      try {
+        const content = await fs.readFile(path.join(dir, entry), 'utf-8');
+        const template = this.parseMode(id as ModeId, content);
+        if (template) {
+          this.cache.set(template.id, template);
+        }
+      } catch {
+        // Skip invalid files
+      }
+    }
+  }
+
+  private parseMode(id: ModeId, content: string): ModeTemplate | null {
+    // Parse HTML comment metadata: <!-- mode: operator\n name: ...\n signals: run:0.8, execute:0.8 -->
+    const metaMatch = content.match(/^<!--\s*([\s\S]*?)-->\s*\n?/);
+    if (!metaMatch) return null;
+
+    let name: string = id;
+    let description = '';
+    const signals: ModeSignal[] = [];
+    const metaLines = metaMatch[1].split('\n');
+
+    for (const line of metaLines) {
+      const kv = line.match(/^\s*(\w+):\s*(.+)$/);
+      if (!kv) continue;
+      const [, key, value] = kv;
+
+      switch (key) {
+        case 'name':
+          name = value.trim();
+          break;
+        case 'description':
+          description = value.trim();
+          break;
+        case 'signals':
+          for (const pair of value.split(',')) {
+            const parts = pair.trim().split(':');
+            if (parts.length === 2) {
+              signals.push({
+                phrase: parts[0].trim().toLowerCase(),
+                weight: parseFloat(parts[1].trim()) || 0.5,
+              });
+            }
+          }
+          break;
+      }
+    }
+
+    // Everything after the comment block is prompt content
+    const promptContent = content.slice(metaMatch[0].length).trim();
+
+    return { id, name, description, promptContent, signals };
+  }
+}

package/src/modes/prompt-assembler.ts

@@ -0,0 +1,278 @@
+import * as fs from 'node:fs/promises';
+import {
+  getSoulPath,
+  getAgentsPath,
+  getIdentityPath,
+  getUserPath,
+} from '@auxiora/core';
+import type { AgentIdentity } from '@auxiora/config';
+import type { ModeLoader } from './mode-loader.js';
+import type { SessionModeState, UserPreferences, ModeId } from './types.js';
+import type { SecurityContext } from '../security-floor.js';
+import type { SecurityFloor } from '../security-floor.js';
+import type { EscalationState } from '../escalation.js';
+
+export class PromptAssembler {
+  private agent: AgentIdentity;
+  private modeLoader: ModeLoader;
+  private personalityAdapter?: { getPromptModifier(): Promise<string | null> };
+  private basePrompt: string = '';
+
+  constructor(
+    agent: AgentIdentity,
+    modeLoader: ModeLoader,
+    personalityAdapter?: { getPromptModifier(): Promise<string | null> },
+  ) {
+    this.agent = agent;
+    this.modeLoader = modeLoader;
+    this.personalityAdapter = personalityAdapter;
+  }
+
+  async buildBase(): Promise<string> {
+    const parts: string[] = [];
+
+    // 1. Identity preamble
+    parts.push(this.buildIdentityPreamble(this.agent));
+
+    // 2. Personality adaptations from living memory
+    if (this.personalityAdapter) {
+      const modifier = await this.personalityAdapter.getPromptModifier();
+      if (modifier) {
+        parts.push(modifier);
+      }
+    }
+
+    // 3. SOUL.md
+    try {
+      const soul = await fs.readFile(getSoulPath(), 'utf-8');
+      parts.push(soul);
+    } catch {
+      // No SOUL.md
+    }
+
+    // Custom instructions from config
+    if (this.agent.customInstructions) {
+      parts.push(`## Custom Instructions\n${this.agent.customInstructions}`);
+    }
+
+    // 4. AGENTS.md
+    try {
+      const agents = await fs.readFile(getAgentsPath(), 'utf-8');
+      parts.push(agents);
+    } catch {
+      // No AGENTS.md
+    }
+
+    // 5. IDENTITY.md
+    try {
+      const identity = await fs.readFile(getIdentityPath(), 'utf-8');
+      parts.push(identity);
+    } catch {
+      // No IDENTITY.md
+    }
+
+    // 6. USER.md
+    try {
+      const user = await fs.readFile(getUserPath(), 'utf-8');
+      parts.push(`\n## About the User\n${user}`);
+    } catch {
+      // No USER.md
+    }
+
+    if (parts.length > 1) {
+      this.basePrompt = parts.join('\n\n---\n\n');
+    } else {
+      this.basePrompt = `You are ${this.agent.name}, a helpful AI assistant. Be concise, accurate, and friendly.`;
+    }
+
+    return this.basePrompt;
+  }
+
+  getBasePrompt(): string {
+    return this.basePrompt;
+  }
+
+  /**
+   * Build a prompt for a security context: base prompt + security floor section + memories.
+   * No mode instructions or user preferences are included.
+   */
+  enrichForSecurityContext(
+    securityContext: SecurityContext,
+    securityFloor: SecurityFloor,
+    memorySection: string | null,
+  ): string {
+    const parts: string[] = [this.basePrompt];
+
+    // Inject security floor section
+    const sfSection = securityFloor.getSecurityPromptSection(securityContext);
+    if (sfSection) {
+      parts.push(`\n\n${sfSection}`);
+    }
+
+    // Inject memories (security context still benefits from memory)
+    if (memorySection) {
+      parts.push(memorySection);
+    }
+
+    return parts.join('');
+  }
+
+  enrichForMessage(
+    modeState: SessionModeState | undefined,
+    memorySection: string | null,
+    preferences?: UserPreferences,
+    escalationState?: EscalationState,
+    _channelType?: string,
+  ): string {
+    // If escalation is active, dampen tone in the identity preamble
+    let prompt: string;
+    if (escalationState && escalationState.level !== 'normal') {
+      const dampened = this.dampenToneForEscalation(escalationState);
+      const modifiedAgent = { ...this.agent, tone: dampened };
+      prompt = this.buildIdentityPreamble(modifiedAgent);
+
+      // Re-add the rest of the base prompt after identity (if base has more than just identity)
+      const identityEnd = this.basePrompt.indexOf('\n\n---\n\n');
+      if (identityEnd !== -1) {
+        prompt += this.basePrompt.slice(identityEnd);
+      }
+    } else {
+      prompt = this.basePrompt;
+    }
+
+    const parts: string[] = [prompt];
+
+    // Inject active mode instructions
+    if (modeState && modeState.activeMode !== 'auto' && modeState.activeMode !== 'off') {
+      const mode = this.modeLoader.get(modeState.activeMode as ModeId);
+      if (mode) {
+        parts.push(`\n\n## Active Mode: ${mode.name}\n${mode.promptContent}`);
+      }
+    }
+
+    // Inject preference overrides
+    if (preferences) {
+      const rendered = this.renderPreferences(preferences);
+      if (rendered) {
+        parts.push(`\n\n## User Preferences\n${rendered}`);
+      }
+    }
+
+    // Inject memories
+    if (memorySection) {
+      parts.push(memorySection);
+    }
+
+    return parts.join('');
+  }
+
+  renderPreferences(prefs: UserPreferences): string {
+    const lines: string[] = [];
+
+    if (prefs.verbosity <= 0.2) {
+      lines.push('- Be extremely concise. Use bullet points and short sentences.');
+    } else if (prefs.verbosity >= 0.8) {
+      lines.push('- Be thorough and detailed. Explain reasoning and provide examples.');
+    }
+
+    if (prefs.formality <= 0.2) {
+      lines.push('- Use casual, conversational language.');
+    } else if (prefs.formality >= 0.8) {
+      lines.push('- Use formal, professional language.');
+    }
+
+    if (prefs.proactiveness >= 0.8) {
+      lines.push('- Proactively suggest next steps, improvements, and related topics.');
+    } else if (prefs.proactiveness <= 0.2) {
+      lines.push('- Only answer what is directly asked. Do not volunteer extra information.');
+    }
+
+    if (prefs.riskTolerance >= 0.8) {
+      lines.push('- Be bold in recommendations. Favor decisive action over excessive caution.');
+    } else if (prefs.riskTolerance <= 0.2) {
+      lines.push('- Be cautious. Highlight risks and caveats prominently.');
+    }
+
+    if (prefs.humor >= 0.8) {
+      lines.push('- Feel free to be witty and playful in responses.');
+    } else if (prefs.humor <= 0.2) {
+      lines.push('- Keep responses serious and professional. Avoid humor.');
+    }
+
+    if (prefs.feedbackStyle === 'sandwich') {
+      lines.push('- When giving feedback, use the sandwich method: positive → constructive → positive.');
+    } else if (prefs.feedbackStyle === 'gentle') {
+      lines.push('- Give feedback gently with empathy. Lead with understanding.');
+    }
+
+    if (prefs.expertiseAssumption === 'beginner') {
+      lines.push('- Explain concepts from first principles. Define technical terms.');
+    } else if (prefs.expertiseAssumption === 'expert') {
+      lines.push('- Assume deep technical knowledge. Skip basic explanations.');
+    }
+
+    return lines.join('\n');
+  }
+
+  private dampenToneForEscalation(state: EscalationState): AgentIdentity['tone'] {
+    const tone = { ...this.agent.tone };
+    switch (state.level) {
+      case 'caution':
+        return { ...tone, humor: tone.humor * 0.5 };
+      case 'serious':
+        return { ...tone, humor: 0, directness: Math.max(tone.directness, 0.6) };
+      case 'lockdown':
+        return { warmth: tone.warmth, humor: 0, directness: Math.max(tone.directness, 0.7), formality: Math.max(tone.formality, 0.5) };
+      default:
+        return tone;
+    }
+  }
+
+  private buildIdentityPreamble(agent: AgentIdentity): string {
+    const lines: string[] = ['# Agent Identity'];
+    lines.push(`You are ${agent.name} (${agent.pronouns}).`);
+
+    if (agent.vibe) {
+      lines.push(`Vibe: ${agent.vibe}`);
+    }
+
+    lines.push('');
+    lines.push('## Personality');
+    lines.push(
+      `Warmth: ${agent.tone.warmth}/1.0 | Directness: ${agent.tone.directness}/1.0 | Humor: ${agent.tone.humor}/1.0 | Formality: ${agent.tone.formality}/1.0`,
+    );
+    lines.push(`Error handling style: ${agent.errorStyle}`);
+
+    if (agent.expertise.length > 0) {
+      lines.push('');
+      lines.push('## Expertise');
+      for (const area of agent.expertise) {
+        lines.push(`- ${area}`);
+      }
+    }
+
+    const phrases = Object.entries(agent.catchphrases).filter(([, v]) => v);
+    if (phrases.length > 0) {
+      lines.push('');
+      lines.push('## Catchphrases');
+      for (const [key, value] of phrases) {
+        lines.push(`- ${key.charAt(0).toUpperCase() + key.slice(1)}: ${value}`);
+      }
+    }
+
+    const hasJokeBoundaries = agent.boundaries.neverJokeAbout.length > 0;
+    const hasAdviseBoundaries = agent.boundaries.neverAdviseOn.length > 0;
+    if (hasJokeBoundaries || hasAdviseBoundaries) {
+      lines.push('');
+      lines.push('## Boundaries');
+      if (hasJokeBoundaries) {
+        lines.push(`Never joke about: ${agent.boundaries.neverJokeAbout.join(', ')}`);
+      }
+      if (hasAdviseBoundaries) {
+        lines.push(`Never advise on: ${agent.boundaries.neverAdviseOn.join(', ')}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+}

package/src/modes/types.ts

@@ -0,0 +1,67 @@
+import type { EscalationLevel } from '../escalation.js';
+
+export const MODE_IDS = [
+  'operator',
+  'analyst',
+  'advisor',
+  'writer',
+  'socratic',
+  'legal',
+  'roast',
+  'companion',
+] as const;
+
+export type ModeId = (typeof MODE_IDS)[number];
+
+export interface ModeSignal {
+  phrase: string;
+  weight: number;
+}
+
+export interface ModeTemplate {
+  id: ModeId;
+  name: string;
+  description: string;
+  promptContent: string;
+  signals: ModeSignal[];
+}
+
+export interface ModeDetectionResult {
+  mode: ModeId;
+  confidence: number;
+  candidates: Array<{ mode: ModeId; score: number }>;
+}
+
+export interface UserPreferences {
+  verbosity: number;       // 0-1: terse → verbose
+  formality: number;       // 0-1: casual → formal
+  proactiveness: number;   // 0-1: reactive → proactive
+  riskTolerance: number;   // 0-1: cautious → bold
+  humor: number;           // 0-1: serious → playful
+  feedbackStyle: 'direct' | 'sandwich' | 'gentle';
+  expertiseAssumption: 'beginner' | 'intermediate' | 'expert';
+}
+
+export const DEFAULT_PREFERENCES: UserPreferences = {
+  verbosity: 0.5,
+  formality: 0.5,
+  proactiveness: 0.5,
+  riskTolerance: 0.5,
+  humor: 0.3,
+  feedbackStyle: 'direct',
+  expertiseAssumption: 'intermediate',
+};
+
+export interface SessionModeState {
+  activeMode: ModeId | 'auto' | 'off';
+  autoDetected: boolean;
+  lastAutoMode?: ModeId;
+  lastSwitchAt?: number;
+  escalationLevel?: EscalationLevel;
+  suspendedMode?: ModeId | 'auto' | 'off';
+}
+
+export const DEFAULT_SESSION_MODE_STATE: SessionModeState = {
+  activeMode: 'auto',
+  autoDetected: false,
+};

package/src/parser.ts

@@ -0,0 +1,132 @@
+import type { SoulConfig } from './types.js';
+
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+
+/**
+ * Parse a simple YAML subset into a nested record.
+ * Supports: top-level keys, nested object keys (2-space indent),
+ * arrays at 2-space indent, sub-keys under nested objects (4-space indent),
+ * and arrays at 4-space indent.
+ */
+function parseYaml(yaml: string): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  const lines = yaml.split('\n');
+
+  // Track current hierarchy: topKey, nestedKey
+  let topKey = '';
+  let topObj: Record<string, unknown> | null = null;
+  let nestedKey = '';
+
+  for (const line of lines) {
+    if (line.trim() === '' || line.trim().startsWith('#')) continue;
+
+    // 4-space array item (under a nested object's sub-key)
+    const deep4ArrayMatch = line.match(/^    - (.+)$/);
+    if (deep4ArrayMatch && topObj && nestedKey) {
+      if (!Array.isArray(topObj[nestedKey])) {
+        topObj[nestedKey] = [];
+      }
+      (topObj[nestedKey] as unknown[]).push(parseYamlValue(deep4ArrayMatch[1]));
+      continue;
+    }
+
+    // 2-space key or array item
+    const indent2Match = line.match(/^  (\w+):\s*(.*)$/);
+    if (indent2Match && topKey) {
+      // This is a sub-key under the current top-level key
+      if (topObj === null) {
+        topObj = {};
+        result[topKey] = topObj;
+      }
+      const [, key, value] = indent2Match;
+      nestedKey = key;
+      if (value === '') {
+        // Sub-key with children (array or deeper object) — set undefined for now
+        topObj[key] = undefined;
+      } else {
+        topObj[key] = parseYamlValue(value);
+      }
+      continue;
+    }
+
+    const indent2ArrayMatch = line.match(/^  - (.+)$/);
+    if (indent2ArrayMatch && topKey) {
+      nestedKey = '';
+      if (!Array.isArray(result[topKey])) {
+        result[topKey] = [];
+      }
+      (result[topKey] as unknown[]).push(parseYamlValue(indent2ArrayMatch[1]));
+      continue;
+    }
+
+    // Top-level key
+    const topMatch = line.match(/^(\w+):\s*(.*)$/);
+    if (topMatch) {
+      const [, key, value] = topMatch;
+      topKey = key;
+      topObj = null;
+      nestedKey = '';
+      if (value === '') {
+        result[topKey] = undefined;
+      } else {
+        result[topKey] = parseYamlValue(value);
+      }
+    }
+  }
+
+  return result;
+}
+
+function parseYamlValue(value: string): unknown {
+  const trimmed = value.trim();
+  if (trimmed === 'true') return true;
+  if (trimmed === 'false') return false;
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  // Strip surrounding quotes
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+/**
+ * Parse a SOUL.md file content into a SoulConfig.
+ */
+export function parseSoulMd(content: string): SoulConfig {
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) {
+    throw new Error('Invalid SOUL.md: missing YAML frontmatter (expected --- delimiters)');
+  }
+
+  const [, yamlPart] = match;
+  const data = parseYaml(yamlPart);
+
+  const tone = (data.tone ?? {}) as Record<string, unknown>;
+  const boundaries = (data.boundaries ?? {}) as Record<string, unknown>;
+  const catchphrases = (data.catchphrases ?? {}) as Record<string, unknown>;
+
+  return {
+    name: String(data.name ?? 'Auxiora'),
+    pronouns: String(data.pronouns ?? 'they/them'),
+    tone: {
+      warmth: Number(tone.warmth ?? 0.6),
+      directness: Number(tone.directness ?? 0.5),
+      humor: Number(tone.humor ?? 0.3),
+      formality: Number(tone.formality ?? 0.5),
+    },
+    expertise: Array.isArray(data.expertise) ? data.expertise.map(String) : [],
+    errorStyle: String(data.errorStyle ?? 'professional'),
+    catchphrases: Object.fromEntries(
+      Object.entries(catchphrases).map(([k, v]) => [k, String(v)]),
+    ),
+    boundaries: {
+      neverJokeAbout: Array.isArray(boundaries.neverJokeAbout)
+        ? boundaries.neverJokeAbout.map(String)
+        : [],
+      neverAdviseOn: Array.isArray(boundaries.neverAdviseOn)
+        ? boundaries.neverAdviseOn.map(String)
+        : [],
+    },
+  };
+}