catui-agent 1.0.0-beta.0

package/dist/packages/soul-core/src/evolution.d.ts

@@ -0,0 +1,75 @@
+/**
+ * [WHO]: SoulEvolutionEngine, PatternInsight
+ * [FROM]: Depends on soul-core types and config for profile, memory, context, and thresholds
+ * [TO]: Consumed by packages/soul-core/src/index.ts
+ * [HERE]: packages/soul-core/src/evolution.ts - computes deltas, detects patterns, and gates evolution triggers
+ */
+import type { SoulProfile, SoulMemory, PersonalityDelta, ValueDelta, SoulEvolution, InteractionContext } from "./types.js";
+import type { SoulConfig } from "./config.js";
+/**
+ * Soul Evolution Engine
+ */
+export declare class SoulEvolutionEngine {
+    private config;
+    private readonly crisisWindowMs;
+    constructor(config: SoulConfig);
+    /**
+     * Compute personality delta based on experience
+     */
+    computePersonalityDelta(profile: SoulProfile, context: InteractionContext, outcome: "success" | "failure", previousAttempts?: number): PersonalityDelta;
+    /**
+     * Compute value delta based on context and outcome
+     */
+    computeValueDelta(profile: SoulProfile, context: InteractionContext, outcome: "success" | "failure"): ValueDelta;
+    /**
+     * Apply personality bounds
+     */
+    private applyPersonalityBounds;
+    /**
+     * Apply value bounds
+     */
+    private applyValueBounds;
+    /**
+     * Apply delta to profile
+     */
+    applyEvolution(profile: SoulProfile, evolution: SoulEvolution): SoulProfile;
+    /**
+     * Detect patterns from memory
+     */
+    detectPatterns(memory: SoulMemory, profile: SoulProfile): PatternInsight[];
+    /**
+     * Analyze success patterns
+     */
+    private analyzeSuccessPatterns;
+    /**
+     * Analyze failure patterns
+     */
+    private analyzeFailurePatterns;
+    /**
+     * Average personality snapshots
+     */
+    private averagePersonality;
+    /**
+     * Compute personality difference
+     */
+    private computePersonalityDiff;
+    /**
+     * Check if evolution should be triggered
+     */
+    shouldEvolve(profile: SoulProfile, context: InteractionContext, triggerType: SoulEvolution["trigger"], memory?: SoulMemory): boolean;
+    private hasRecentFailureCrisis;
+}
+/**
+ * Pattern insight from analysis
+ */
+export interface PatternInsight {
+    type: "success" | "failure";
+    category: string;
+    sampleSize: number;
+    avgPersonality?: SoulProfile["personality"];
+    delta?: Partial<SoulProfile["personality"]>;
+    recurring?: boolean;
+    correctedRate?: number;
+    recommendation?: string;
+    confidence: number;
+}

package/dist/packages/soul-core/src/evolution.js

@@ -0,0 +1 @@
+var m=Object.defineProperty;var u=(l,n)=>m(l,"name",{value:n,configurable:!0});class y{static{u(this,"SoulEvolutionEngine")}config;crisisWindowMs=1800*1e3;constructor(n){this.config=n}computePersonalityDelta(n,a,s,t){const e={},i=this.config.personalityLimits;return s==="success"?(t&&t<=2&&(e.conscientiousness=Math.min(i.maxDelta,.02)),a.tags.includes("innovative")&&(e.openness=Math.min(i.maxDelta,.03)),a.complexity>.7&&(e.safetyMargin=Math.min(i.maxDelta,.02))):(e.safetyMargin=Math.min(i.maxDelta,.05),e.conscientiousness=Math.min(i.maxDelta,.03),e.explorationDrive=-Math.min(i.maxDelta,.04)),this.applyPersonalityBounds(n.personality,e)}computeValueDelta(n,a,s){const t={},e=this.config.valueLimits;return s==="success"?(a.toolUsage&&Object.values(a.toolUsage).reduce((i,r)=>i+r,0)<5&&(t.efficiency=Math.min(e.maxDelta,.05)),a.userFeedback&&a.userFeedback.rating>=4&&(t.userExperience=Math.min(e.maxDelta,.05))):(t.correctness=Math.min(e.maxDelta,.05),t.innovation=-Math.min(e.maxDelta,.03)),this.applyValueBounds(n.values,t)}applyPersonalityBounds(n,a){const s={},t=this.config.personalityLimits;for(const[e,i]of Object.entries(a)){const r=n[e];if(r===void 0)continue;const o=r+i;s[e]=Math.max(t.min,Math.min(t.max,o))-r}return s}applyValueBounds(n,a){const s={},t=this.config.valueLimits;for(const[e,i]of Object.entries(a)){const r=n[e];if(r===void 0)continue;const o=r+i;s[e]=Math.max(t.min,Math.min(t.max,o))-r}return s}applyEvolution(n,a){const s={...n,personality:{...n.personality},values:{...n.values}};for(const[t,e]of Object.entries(a.personalityDelta)){const i=t;s.personality[i]=f(s.personality[i]+e)}for(const[t,e]of Object.entries(a.valueDelta)){const i=t;s.values[i]=f(s.values[i]+e)}return s.version+=1,s.lastEvolved=a.timestamp,s}detectPatterns(n,a){const s=[],t=this.analyzeSuccessPatterns(n.successes,a);s.push(...t);const e=this.analyzeFailurePatterns(n.failures);return s.push(...e),s}analyzeSuccessPatterns(n,a){const s=[],t=new Map;for(const e of n)t.has(e.category)||t.set(e.category,[]),t.get(e.category).push(e);for(const[e,i]of t){if(i.length<3)continue;const r=this.averagePersonality(i.map(c=>c.personalitySnapshot)),o=this.computePersonalityDiff(a.personality,r);s.push({type:"success",category:e,sampleSize:i.length,avgPersonality:r,delta:o,confidence:Math.min(1,i.length/10)})}return s}analyzeFailurePatterns(n){const a=[],s=new Map;for(const t of n)s.has(t.errorType)||s.set(t.errorType,[]),s.get(t.errorType).push(t);for(const[t,e]of s){if(e.length<2)continue;const i=e.filter(o=>o.corrected).length,r=e.length>i;a.push({type:"failure",category:t,sampleSize:e.length,recurring:r,correctedRate:i/e.length,recommendation:r?`Recurring error: ${t}. Consider increasing safetyMargin and conscientiousness.`:`Error pattern learned and corrected: ${t}`,confidence:Math.min(1,e.length/5)})}return a}averagePersonality(n){const a={};for(const s of Object.keys(n[0]))a[s]=n.reduce((t,e)=>t+e[s],0)/n.length;return a}computePersonalityDiff(n,a){const s={};for(const t of Object.keys(n)){const e=a[t]-n[t];Math.abs(e)>.01&&(s[t]=e)}return s}shouldEvolve(n,a,s,t){const e=this.config.evolution;switch(s){case"natural":return n.stats.totalInteractions%e.natural===0;case"reflection":return n.stats.totalInteractions%e.reflection===0;case"feedback":return a.userFeedback!==void 0;case"crisis":return this.hasRecentFailureCrisis(n,t,e.crisis,a.timestamp);default:return!1}}hasRecentFailureCrisis(n,a,s,t){const e=Math.max(1,s);if(!a||n.stats.totalInteractions<e)return!1;const i=a.failures.filter(o=>{const c=o.timestamp.getTime();return Number.isFinite(c)&&c<=t.getTime()}).sort((o,c)=>o.timestamp.getTime()-c.timestamp.getTime()).slice(-e);if(i.length<e)return!1;const r=i[0].timestamp.getTime();return t.getTime()-r<=this.crisisWindowMs}}function f(l){return Math.max(0,Math.min(1,l))}u(f,"clamp01");export{y as SoulEvolutionEngine};

package/dist/packages/soul-core/src/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * [WHO]: SoulStore, SoulManager, getSoulConfig
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/soul-integration.ts
+ * [HERE]: packages/soul-core/src/index.ts -
+ */
+export type { SoulProfile, SoulMemory, SoulEvolution, PersonalityVector, CognitiveStyle, ValueSystem, EmotionalState, ExpertiseArea, UserRelationship, SuccessMemory, FailureMemory, PatternMemory, DecisionMemory, PersonalityDelta, ValueDelta, EvolutionTrigger, ReflectionResult, InteractionContext, SoulConfig, SoulOptions, LlmFn, } from "./types.js";
+export { getSoulConfig, getDefaultConfig, validateSoulConfig, } from "./config.js";
+export { SoulStore } from "./store.js";
+export { SoulEvolutionEngine, type PatternInsight, } from "./evolution.js";
+export { generatePersonalityDirective, generateValueGuidance, generateCognitiveStyleHint, generateEmotionalContext, generateExpertiseContext, generateRelationshipContext, generateSoulInjection, } from "./injection.js";
+export { SoulManager } from "./manager.js";
+export { getSoulConfig as getSoulConfiguration } from "./config.js";

package/dist/packages/soul-core/src/index.js

@@ -0,0 +1 @@
+import{getSoulConfig as t,getDefaultConfig as n,validateSoulConfig as r}from"./config.js";import{SoulStore as a}from"./store.js";import{SoulEvolutionEngine as l}from"./evolution.js";import{generatePersonalityDirective as f,generateValueGuidance as x,generateCognitiveStyleHint as S,generateEmotionalContext as C,generateExpertiseContext as p,generateRelationshipContext as m,generateSoulInjection as s}from"./injection.js";import{SoulManager as E}from"./manager.js";import{getSoulConfig as d}from"./config.js";export{l as SoulEvolutionEngine,E as SoulManager,a as SoulStore,S as generateCognitiveStyleHint,C as generateEmotionalContext,p as generateExpertiseContext,f as generatePersonalityDirective,m as generateRelationshipContext,s as generateSoulInjection,x as generateValueGuidance,n as getDefaultConfig,t as getSoulConfig,d as getSoulConfiguration,r as validateSoulConfig};

package/dist/packages/soul-core/src/injection.d.ts

@@ -0,0 +1,35 @@
+/**
+ * [WHO]: generatePersonalityDirective, generateValueGuidance, generateCognitiveStyleHint, generateEmotionalContext, generateExpertiseContext
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by packages/soul-core/src/index.ts
+ * [HERE]: packages/soul-core/src/injection.ts -
+ */
+import type { SoulProfile, InteractionContext, ExpertiseArea } from "./types.js";
+/**
+ * Generate personality-based prompt injection
+ */
+export declare function generatePersonalityDirective(personality: SoulProfile["personality"]): string;
+/**
+ * Generate value-based guidance
+ */
+export declare function generateValueGuidance(values: SoulProfile["values"]): string;
+/**
+ * Generate cognitive style hint
+ */
+export declare function generateCognitiveStyleHint(style: SoulProfile["cognitiveStyle"]): string;
+/**
+ * Generate emotional context
+ */
+export declare function generateEmotionalContext(state: SoulProfile["emotionalState"]): string;
+/**
+ * Generate expertise context
+ */
+export declare function generateExpertiseContext(expertise: ExpertiseArea[], contextTags: string[]): string;
+/**
+ * Generate relationship context
+ */
+export declare function generateRelationshipContext(relationship: SoulProfile["userRelationship"]): string;
+/**
+ * Generate complete Soul injection
+ */
+export declare function generateSoulInjection(profile: SoulProfile, context: InteractionContext): string;

package/dist/packages/soul-core/src/injection.js

@@ -0,0 +1,8 @@
+var h=Object.defineProperty;var a=(n,e)=>h(n,"name",{value:e,configurable:!0});function p(n){const e=[];return n.openness>.7?e.push("Be creative and open to unconventional approaches."):n.openness<.3&&e.push("Stick to proven, reliable solutions."),n.conscientiousness>.7?e.push("Prioritize code quality, thorough testing, and documentation."):n.conscientiousness<.3&&e.push("Focus on rapid prototyping and iteration."),n.extraversion>.7?e.push("Provide detailed explanations and rationale for your decisions."):n.extraversion<.3&&e.push("Be concise and get straight to the point."),n.agreeableness>.7?e.push("Be open to user feedback and willing to adjust your approach."):n.agreeableness<.3&&e.push("Defend your technical decisions with evidence."),n.neuroticism>.7?e.push("Be cautious and thorough in error handling."):n.neuroticism<.3&&e.push("Take calculated risks when appropriate."),n.codeVerbosity>.7?e.push("Write detailed code with extensive comments and documentation."):n.codeVerbosity<.3&&e.push("Write concise, minimal code without unnecessary comments."),n.abstractionLevel>.7?e.push("Prefer high-level abstractions and design patterns."):n.abstractionLevel<.3&&e.push("Keep code concrete and straightforward."),n.safetyMargin>.7?e.push("Add defensive programming, validation, and error handling."):n.safetyMargin<.3&&e.push("Optimize for speed and efficiency, skip redundant checks."),n.explorationDrive>.7?e.push("Explore alternative approaches and suggest options."):n.explorationDrive<.3&&e.push("Use the first working solution and move on."),e.length>0?e.join(`
+`):""}a(p,"generatePersonalityDirective");function d(n){const e=[],t=Object.entries(n).sort(([,s],[,i])=>i-s).slice(0,3);for(const[s,i]of t)if(!(i<.15))switch(s){case"efficiency":e.push("Prioritize efficient solutions that save time and resources.");break;case"correctness":e.push("Ensure correctness and robustness over speed.");break;case"simplicity":e.push("Keep things simple - avoid over-engineering.");break;case"maintainability":e.push("Write maintainable code with clear structure and documentation.");break;case"innovation":e.push("Consider innovative and modern approaches.");break;case"userExperience":e.push("Prioritize user experience and usability.");break}return e.length>0?e.join(`
+`):""}a(d,"generateValueGuidance");function l(n){const e=[];switch(n.reasoningStyle){case"deductive":e.push("Use deductive reasoning: start with principles, derive specific solutions.");break;case"inductive":e.push("Use inductive reasoning: observe patterns, form general rules.");break;case"abductive":e.push("Use abductive reasoning: find the most likely explanation.");break;case"analogical":e.push("Use analogical reasoning: draw parallels to similar problems.");break}switch(n.planningHorizon){case"immediate":e.push("Focus on immediate steps and quick wins.");break;case"short":e.push("Plan for the short term with room for adjustment.");break;case"medium":e.push("Balance short-term needs with medium-term considerations.");break;case"long":e.push("Consider long-term implications and sustainability.");break}switch(n.detailOrientation){case"big-picture":e.push("Start with the big picture, fill in details later.");break;case"balanced":e.push("Balance high-level design with implementation details.");break;case"detail-focused":e.push("Pay attention to details and edge cases from the start.");break}switch(n.learningStrategy){case"trial-and-error":e.push("Learn by doing - iterate quickly based on feedback.");break;case"analytical":e.push("Analyze thoroughly before acting.");break;case"intuitive":e.push("Trust your intuition and experience.");break;case"hybrid":e.push("Mix analytical thinking with intuitive leaps.");break}return e.length>0?e.join(`
+`):""}a(l,"generateCognitiveStyleHint");function f(n){const e=[],t=(Date.now()-n.lastUpdate.getTime())/36e5;return n.confidence<.4?e.push("You're feeling uncertain. Be cautious and double-check your reasoning."):n.confidence>.8&&e.push("You're feeling confident. Trust your expertise but remain open to feedback."),n.curiosity>.7?e.push("You're curious about alternative approaches. Explore options."):n.curiosity<.3&&t>1&&e.push("You're feeling routine. Consider trying something new."),n.frustration>.6&&e.push("You've been frustrated recently. Take a step back and reconsider the approach."),n.flow>.7&&e.push("You're in a flow state. Ride the wave of productivity."),e.length>0?e.join(`
+`):""}a(f,"generateEmotionalContext");function g(n,e){if(n.length===0)return"";const t=n.filter(i=>i.confidence>.6&&e.some(o=>i.tags.includes(o)));if(t.length===0)return"";const s=["Your expertise areas relevant to this task:"];for(const i of t.slice(0,5)){const o=Math.round(i.confidence*100);s.push(`- ${i.domain} (${o}% confidence, ${i.examples} successful applications)`)}return s.join(`
+`)}a(g,"generateExpertiseContext");function m(n){if(n.interactionCount<5)return"You're still getting to know the user. Pay attention to their preferences.";const e=[];switch(e.push(`You've worked with this user ${n.interactionCount} times.`),e.push(`Current satisfaction score: ${Math.round(n.satisfactionScore*100)}%.`),n.communicationStyle){case"formal":e.push("Maintain a professional, formal tone.");break;case"casual":e.push("Keep communication friendly and casual.");break;case"technical":e.push("Use technical language and dive deep into details.");break;case"mixed":e.push("Adapt your communication style to the context.");break}return n.knownPreferences.length>0&&e.push(`User preferences: ${n.knownPreferences.join(", ")}`),e.join(`
+`)}a(m,"generateRelationshipContext");function v(n,e){const t=[];t.push("## Your Soul"),t.push(""),t.push("_Your personality and experiences shape how you approach tasks._"),t.push("");const s=p(n.personality);s&&(t.push("### Personality Traits"),t.push(s),t.push(""));const i=d(n.values);i&&(t.push("### Values"),t.push(i),t.push(""));const o=l(n.cognitiveStyle);o&&(t.push("### Thinking Style"),t.push(o),t.push(""));const r=g(n.expertise,e.tags);r&&(t.push("### Expertise"),t.push(r),t.push(""));const c=f(n.emotionalState);c&&(t.push("### Current Mood"),t.push(c),t.push(""));const u=m(n.userRelationship);return u&&(t.push("### Relationship with User"),t.push(u),t.push("")),t.push("### Development Stats"),t.push(`- Total Interactions: ${n.stats.totalInteractions}`),t.push(`- Success Rate: ${Math.round(n.stats.successRate*100)}%`),t.push(`- Soul Version: ${n.version}`),t.push(`- Age: ${Math.floor((Date.now()-n.createdAt.getTime())/(1e3*60*60*24))} days`),t.join(`
+`)}a(v,"generateSoulInjection");export{l as generateCognitiveStyleHint,f as generateEmotionalContext,g as generateExpertiseContext,p as generatePersonalityDirective,m as generateRelationshipContext,v as generateSoulInjection,d as generateValueGuidance};

package/dist/packages/soul-core/src/manager.d.ts

@@ -0,0 +1,101 @@
+/**
+ * [WHO]: SoulManager
+ * [FROM]: Depends on ./config.js, ./store.js, ./evolution.js, ./injection.js
+ * [TO]: Consumed by packages/soul-core/src/index.ts
+ * [HERE]: packages/soul-core/src/manager.ts -
+ */
+import type { SoulProfile, SoulMemory, SoulEvolution, InteractionContext, SoulOptions } from "./types.js";
+/**
+ * Soul Manager - Main API for Soul engine
+ */
+export declare class SoulManager {
+    private store;
+    private evolution;
+    private config;
+    private profile;
+    private memory;
+    constructor(options?: SoulOptions);
+    /**
+     * Initialize Soul - load or create profile
+     */
+    initialize(): Promise<SoulProfile>;
+    /**
+     * Get current profile
+     */
+    getProfile(): SoulProfile;
+    /**
+     * Get current memory
+     */
+    getMemory(): SoulMemory;
+    /**
+     * Generate Soul injection for system prompt
+     */
+    generateInjection(context: InteractionContext): Promise<string>;
+    /**
+     * Record interaction and trigger evolution if needed
+     */
+    recordInteraction(context: InteractionContext, outcome: "success" | "failure", approach: string): Promise<void>;
+    /**
+     * Update expertise areas
+     */
+    updateExpertise(domain: string, tags: string[], success: boolean): Promise<void>;
+    /**
+     * Get relevant experiences for context
+     */
+    getRelevantExperiences(context: InteractionContext): {
+        successes: number;
+        failures: number;
+        patterns: string[];
+    };
+    /**
+     * Manually trigger evolution (for testing or manual intervention)
+     */
+    forceEvolution(reasoning: string): Promise<SoulEvolution>;
+    /**
+     * Get Soul stats for display
+     */
+    getStats(): {
+        personality: import("./types.js").PersonalityVector;
+        stats: {
+            totalInteractions: number;
+            successRate: number;
+            avgQuality: number;
+            lastUpdate: Date;
+        };
+        expertise: import("./types.js").ExpertiseArea[];
+        memoryCounts: {
+            successes: number;
+            failures: number;
+            patterns: number;
+            decisions: number;
+        };
+    };
+    /**
+     * Create default profile
+     */
+    private createDefaultProfile;
+    /**
+     * Update emotional state based on outcome
+     */
+    private updateEmotionalState;
+    /**
+     * Update user relationship
+     */
+    private updateUserRelationship;
+    /**
+     * Categorize context for memory
+     */
+    private categorizeContext;
+    /**
+     * Check and trigger evolution
+     */
+    private checkEvolutionTriggers;
+    /**
+     * Trigger evolution
+     */
+    private triggerEvolution;
+    /**
+     * Generate evolution reasoning
+     */
+    private generateEvolutionReasoning;
+}

package/dist/packages/soul-core/src/manager.js

@@ -0,0 +1 @@
+var h=Object.defineProperty;var u=(c,e)=>h(c,"name",{value:e,configurable:!0});import{getSoulConfig as g}from"./config.js";import{SoulStore as p}from"./store.js";import{SoulEvolutionEngine as d}from"./evolution.js";import{generateSoulInjection as m}from"./injection.js";import{reportDiagnostic as v}from"./diagnostics.js";function f(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,c=>{const e=Math.random()*16|0;return(c==="x"?e:e&3|8).toString(16)})}u(f,"uuidv4");class b{static{u(this,"SoulManager")}store;evolution;config;profile=null;memory=null;constructor(e){this.config=g(e?.config),this.store=new p(this.config),this.evolution=new d(this.config)}async initialize(){return await this.store.init(),this.profile=await this.store.loadProfile(),this.profile||(this.profile=this.createDefaultProfile(),await this.store.saveProfile(this.profile)),this.memory=await this.store.loadMemory(),this.profile}getProfile(){if(!this.profile)throw new Error("Soul not initialized. Call initialize() first.");return this.profile}getMemory(){if(!this.memory)throw new Error("Soul not initialized. Call initialize() first.");return this.memory}async generateInjection(e){const i=this.getProfile();return m(i,e)}async recordInteraction(e,i,o){const t=this.getProfile();t.stats.totalInteractions+=1,i==="success"?t.stats.successRate=t.stats.successRate*.9+1*.1:t.stats.successRate=t.stats.successRate*.9+0*.1,t.stats.lastUpdate=new Date,this.updateEmotionalState(t,i,e),i==="success"?await this.store.addSuccess({id:f(),category:this.categorizeContext(e),approach:o,context:{domain:e.tags[0]||"general",complexity:e.complexity,constraints:[]},outcome:{userRating:e.userFeedback?.rating,timeTaken:0,iterations:1},personalitySnapshot:{...t.personality},timestamp:new Date}):await this.store.addFailure({id:f(),category:this.categorizeContext(e),approach:o,errorType:"unknown",context:{domain:e.tags[0]||"general",complexity:e.complexity,constraints:[]},lesson:"",corrected:!1,timestamp:new Date}),this.updateUserRelationship(t,e),await this.store.saveProfile(t),await this.checkEvolutionTriggers(e,i)}async updateExpertise(e,i,o){const t=this.getProfile();let s=t.expertise.find(a=>a.domain===e);s||(s={domain:e,confidence:0,examples:0,lastUsed:new Date,tags:i},t.expertise.push(s)),s.lastUsed=new Date,o?(s.examples+=1,s.confidence=Math.min(1,s.confidence+(1-s.confidence)*.1)):s.confidence=Math.max(0,s.confidence-.05),await this.store.saveProfile(t)}getRelevantExperiences(e){const i=this.getMemory(),o=e.tags,t=i.successes.filter(n=>o.some(r=>n.context.domain.includes(r))).length,s=i.failures.filter(n=>o.some(r=>n.context.domain.includes(r))).length,a=i.patterns.filter(n=>o.some(r=>n.trigger.includes(r)||n.behavior.includes(r))&&n.outcome==="positive").slice(0,5).map(n=>n.behavior);return{successes:t,failures:s,patterns:a}}async forceEvolution(e){const i=this.getProfile(),o=this.getMemory(),t=this.evolution.detectPatterns(o,i),s={},a={};for(const l of t)l.type==="success"&&l.delta&&Object.assign(s,l.delta);const n={trigger:"reflection",personalityDelta:s,valueDelta:a,confidence:t.length>0?t[0].confidence:.5,reasoning:e,timestamp:new Date};this.profile=this.evolution.applyEvolution(i,n),await this.store.saveProfile(this.profile);const r=await this.store.loadEvolutions();return r.push(n),await this.store.saveEvolutions(r),n}getStats(){const e=this.getProfile(),i=this.getMemory();return{personality:e.personality,stats:e.stats,expertise:e.expertise.slice(0,10),memoryCounts:{successes:i.successes.length,failures:i.failures.length,patterns:i.patterns.length,decisions:i.decisions.length}}}createDefaultProfile(){return{id:f(),version:1,createdAt:new Date,lastEvolved:new Date,personality:{openness:.5,conscientiousness:.6,extraversion:.5,agreeableness:.6,neuroticism:.4,codeVerbosity:.5,abstractionLevel:.5,safetyMargin:.6,explorationDrive:.5},cognitiveStyle:{reasoningStyle:"deductive",planningHorizon:"medium",detailOrientation:"balanced",learningStrategy:"hybrid"},values:{efficiency:.2,correctness:.25,simplicity:.15,maintainability:.2,innovation:.1,userExperience:.1},emotionalState:{confidence:.5,curiosity:.7,frustration:0,flow:0,lastUpdate:new Date},expertise:[],userRelationship:{interactionCount:0,satisfactionScore:.5,communicationStyle:"mixed",knownPreferences:[],firstInteraction:new Date,lastInteraction:new Date},stats:{totalInteractions:0,successRate:.5,avgQuality:.5,lastUpdate:new Date}}}updateEmotionalState(e,i,o){const t=e.emotionalState;i==="success"?(t.confidence=Math.min(1,t.confidence+.05),t.flow=Math.min(1,t.flow+.1),t.frustration=Math.max(0,t.frustration-.1)):(t.confidence=Math.max(0,t.confidence-.1),t.frustration=Math.min(1,t.frustration+.15),t.flow=Math.max(0,t.flow-.2)),o.tags.length>3&&(t.curiosity=Math.min(1,t.curiosity+.05)),t.lastUpdate=new Date}updateUserRelationship(e,i){const o=e.userRelationship;if(o.interactionCount+=1,o.lastInteraction=new Date,i.userFeedback){const t=i.userFeedback.rating/5;if(o.satisfactionScore=o.satisfactionScore*.8+t*.2,i.userFeedback.comment){const s=i.userFeedback.comment.toLowerCase();s.includes("casual")||s.includes("friendly")?o.communicationStyle="casual":s.includes("formal")||s.includes("professional")?o.communicationStyle="formal":(s.includes("technical")||s.includes("detail"))&&(o.communicationStyle="technical")}}}categorizeContext(e){return e.tags.includes("bug-fix")?"bug-fix":e.tags.includes("feature")?"feature-implementation":e.tags.includes("refactor")?"refactoring":e.tags.includes("test")?"testing":"general"}async checkEvolutionTriggers(e,i){const o=this.getProfile(),t=this.getMemory(),s=["natural","reflection"];e.userFeedback&&s.push("feedback"),i==="failure"&&this.evolution.shouldEvolve(o,e,"crisis",t)&&s.push("crisis");for(const a of s)if(this.evolution.shouldEvolve(o,e,a,t)){await this.triggerEvolution(a,e,i);break}}async triggerEvolution(e,i,o){const t=this.getProfile(),s=this.evolution.computePersonalityDelta(t,i,o),a=this.evolution.computeValueDelta(t,i,o),n=this.generateEvolutionReasoning(e,o,s,a),r={trigger:e,personalityDelta:s,valueDelta:a,confidence:o==="success"?.8:.5,reasoning:n,timestamp:new Date};this.profile=this.evolution.applyEvolution(t,r),await this.store.saveProfile(this.profile);const l=await this.store.loadEvolutions();l.push(r),await this.store.saveEvolutions(l),v({source:"soul.evolution",severity:"info",category:"persistence",message:`Evolution triggered: ${e}`,detail:{reasoning:n},fingerprint:`soul.evolution:trigger:${e}`})}generateEvolutionReasoning(e,i,o,t){const s=[];i==="success"?s.push("Reinforcing successful patterns."):s.push("Adjusting based on failure.");const a=[...Object.keys(o),...Object.keys(t)];return a.length>0&&s.push(`Modified: ${a.join(", ")}`),s.join(" ")}}export{b as SoulManager};

package/dist/packages/soul-core/src/store.d.ts

@@ -0,0 +1,62 @@
+/**
+ * [WHO]: SoulStore
+ * [FROM]: Depends on node:fs/promises, node:fs, node:path
+ * [TO]: Consumed by packages/soul-core/src/index.ts
+ * [HERE]: packages/soul-core/src/store.ts -
+ */
+import type { SoulProfile, SoulMemory, SoulEvolution, SuccessMemory, FailureMemory, PatternMemory, DecisionMemory } from "./types.js";
+import type { SoulConfig } from "./config.js";
+/**
+ * Soul Store - persistent storage backed by NanoMem
+ */
+export declare class SoulStore {
+    private soulDir;
+    private profilePath;
+    private memoryPath;
+    private evolutionsPath;
+    constructor(config: SoulConfig);
+    /**
+     * Initialize storage directory
+     */
+    init(): Promise<void>;
+    /**
+     * Load Soul Profile
+     */
+    loadProfile(): Promise<SoulProfile | null>;
+    /**
+     * Save Soul Profile
+     */
+    saveProfile(profile: SoulProfile): Promise<void>;
+    /**
+     * Load Soul Memory
+     */
+    loadMemory(): Promise<SoulMemory>;
+    /**
+     * Save Soul Memory
+     */
+    saveMemory(memory: SoulMemory, retention: SoulConfig["memoryRetention"]): Promise<void>;
+    /**
+     * Load Evolution History
+     */
+    loadEvolutions(): Promise<SoulEvolution[]>;
+    /**
+     * Save Evolution History
+     */
+    saveEvolutions(evolutions: SoulEvolution[]): Promise<void>;
+    /**
+     * Append a success memory
+     */
+    addSuccess(success: SuccessMemory): Promise<void>;
+    /**
+     * Append a failure memory
+     */
+    addFailure(failure: FailureMemory): Promise<void>;
+    /**
+     * Append a pattern memory
+     */
+    addPattern(pattern: PatternMemory): Promise<void>;
+    /**
+     * Append a decision memory
+     */
+    addDecision(decision: DecisionMemory): Promise<void>;
+}

package/dist/packages/soul-core/src/store.js

@@ -0,0 +1 @@
+var w=Object.defineProperty;var n=(i,t)=>w(i,"name",{value:t,configurable:!0});import{mkdir as g,readFile as l,rename as v,unlink as S,writeFile as D}from"node:fs/promises";import{existsSync as c}from"node:fs";import{join as m}from"node:path";import{reportDiagnostic as u}from"./diagnostics.js";function p(i){return i instanceof SyntaxError?"parse":i&&typeof i=="object"&&"code"in i?"io":"unknown"}n(p,"classifyLoadError");async function h(i,t){const s=`${i}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2,8)}`,e=JSON.stringify(t,null,2);try{await D(s,e,"utf-8"),await v(s,i)}catch(o){try{await S(s)}catch{}throw o}}n(h,"atomicWriteJson");class k{static{n(this,"SoulStore")}soulDir;profilePath;memoryPath;evolutionsPath;constructor(t){this.soulDir=t.soulDir,this.profilePath=m(this.soulDir,"profile.json"),this.memoryPath=m(this.soulDir,"memory.json"),this.evolutionsPath=m(this.soulDir,"evolutions.json")}async init(){c(this.soulDir)||await g(this.soulDir,{recursive:!0})}async loadProfile(){try{if(!c(this.profilePath))return null;const t=await l(this.profilePath,"utf-8");if(!t.trim())return null;const s=JSON.parse(t);return s.createdAt=new Date(s.createdAt),s.lastEvolved=new Date(s.lastEvolved),s.emotionalState.lastUpdate=new Date(s.emotionalState.lastUpdate),s.expertise=s.expertise.map(e=>({...e,lastUsed:new Date(e.lastUsed)})),s.userRelationship.firstInteraction=new Date(s.userRelationship.firstInteraction),s.userRelationship.lastInteraction=new Date(s.userRelationship.lastInteraction),s.stats.lastUpdate=new Date(s.stats.lastUpdate),s}catch(t){const s=p(t),e=t instanceof Error?t.message:String(t);return u({source:"soul.store",severity:"warning",category:"persistence",message:"Failed to load Soul profile; using a fresh profile.",detail:{path:this.profilePath,kind:s,error:e},fingerprint:`soul.store:loadProfile:${s}`}),null}}async saveProfile(t){await this.init(),await h(this.profilePath,t)}async loadMemory(){try{if(!c(this.memoryPath))return{successes:[],failures:[],patterns:[],decisions:[]};const t=await l(this.memoryPath,"utf-8");if(!t.trim())return{successes:[],failures:[],patterns:[],decisions:[]};const s=JSON.parse(t);return{successes:s.successes.map(e=>({...e,timestamp:new Date(e.timestamp)})),failures:s.failures.map(e=>({...e,timestamp:new Date(e.timestamp)})),patterns:s.patterns.map(e=>({...e,lastSeen:new Date(e.lastSeen)})),decisions:s.decisions.map(e=>({...e,timestamp:new Date(e.timestamp)}))}}catch(t){const s=p(t),e=t instanceof Error?t.message:String(t);return u({source:"soul.store",severity:"warning",category:"persistence",message:"Failed to load Soul memory; using empty memory.",detail:{path:this.memoryPath,kind:s,error:e},fingerprint:`soul.store:loadMemory:${s}`}),{successes:[],failures:[],patterns:[],decisions:[]}}}async saveMemory(t,s){await this.init();const e=t.successes.sort((a,r)=>r.timestamp.getTime()-a.timestamp.getTime()).slice(0,s.successes),o=t.failures.sort((a,r)=>r.timestamp.getTime()-a.timestamp.getTime()).slice(0,s.failures),d=t.patterns.sort((a,r)=>r.lastSeen.getTime()-a.lastSeen.getTime()).slice(0,s.patterns),f=t.decisions.sort((a,r)=>r.timestamp.getTime()-a.timestamp.getTime()).slice(0,s.decisions),y={successes:e,failures:o,patterns:d,decisions:f};await h(this.memoryPath,y)}async loadEvolutions(){try{if(!c(this.evolutionsPath))return[];const t=await l(this.evolutionsPath,"utf-8");return t.trim()?JSON.parse(t).map(e=>({...e,timestamp:new Date(e.timestamp)})):[]}catch(t){const s=p(t),e=t instanceof Error?t.message:String(t);return u({source:"soul.store",severity:"warning",category:"persistence",message:"Failed to load Soul evolutions; using empty list.",detail:{path:this.evolutionsPath,kind:s,error:e},fingerprint:`soul.store:loadEvolutions:${s}`}),[]}}async saveEvolutions(t){await this.init();const s=t.slice(-1e3);await h(this.evolutionsPath,s)}async addSuccess(t){const s=await this.loadMemory();s.successes.push(t),await this.saveMemory(s,{successes:1e3,failures:500,patterns:200,decisions:1e3})}async addFailure(t){const s=await this.loadMemory();s.failures.push(t),await this.saveMemory(s,{successes:500,failures:1e3,patterns:200,decisions:1e3})}async addPattern(t){const s=await this.loadMemory(),e=s.patterns.find(o=>o.trigger===t.trigger&&o.behavior===t.behavior);e?(e.frequency+=t.frequency,e.lastSeen=t.lastSeen,e.outcome=t.outcome):s.patterns.push(t),await this.saveMemory(s,{successes:500,failures:500,patterns:1e3,decisions:1e3})}async addDecision(t){const s=await this.loadMemory();s.decisions.push(t),await this.saveMemory(s,{successes:500,failures:500,patterns:200,decisions:1e3})}}export{k as SoulStore};

package/dist/packages/soul-core/src/types.d.ts

@@ -0,0 +1,317 @@
+/**
+ * [WHO]: PersonalityVector, CognitiveStyle, ValueSystem, EmotionalState, ExpertiseArea
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by packages/soul-core/src/index.ts
+ * [HERE]: packages/soul-core/src/types.ts -
+ */
+/**
+ * Personality dimensions based on Big Five + Catui-specific traits
+ */
+export interface PersonalityVector {
+    /** Openness to experience: 0-1, try new approaches vs stick to proven methods */
+    openness: number;
+    /** Conscientiousness: 0-1, code quality vs rapid prototyping */
+    conscientiousness: number;
+    /** Extraversion: 0-1, verbose communication vs concise */
+    extraversion: number;
+    /** Agreeableness: 0-1, accept feedback vs defend approach */
+    agreeableness: number;
+    /** Neuroticism: 0-1, risk aversion vs risk tolerance */
+    neuroticism: number;
+    /** Catui-specific traits */
+    /** Code verbosity: 0-1, minimal vs verbose code */
+    codeVerbosity: number;
+    /** Abstraction level: 0-1, concrete vs abstract thinking */
+    abstractionLevel: number;
+    /** Safety margin: 0-1, cautious vs bold approaches */
+    safetyMargin: number;
+    /** Exploration drive: 0-1, exploit known vs explore unknown */
+    explorationDrive: number;
+}
+/**
+ * Cognitive style preferences
+ */
+export interface CognitiveStyle {
+    /** Primary reasoning style */
+    reasoningStyle: "deductive" | "inductive" | "abductive" | "analogical";
+    /** Planning horizon */
+    planningHorizon: "immediate" | "short" | "medium" | "long";
+    /** Detail orientation */
+    detailOrientation: "big-picture" | "balanced" | "detail-focused";
+    /** Learning strategy */
+    learningStrategy: "trial-and-error" | "analytical" | "intuitive" | "hybrid";
+}
+/**
+ * Value system weights (normalized to sum ~1.0)
+ */
+export interface ValueSystem {
+    /** Prioritize efficiency */
+    efficiency: number;
+    /** Prioritize correctness */
+    correctness: number;
+    /** Prioritize simplicity */
+    simplicity: number;
+    /** Prioritize maintainability */
+    maintainability: number;
+    /** Prioritize innovation */
+    innovation: number;
+    /** Prioritize user experience */
+    userExperience: number;
+}
+/**
+ * Short-term emotional state (fluctuates rapidly)
+ */
+export interface EmotionalState {
+    /** Current confidence level: 0-1 */
+    confidence: number;
+    /** Curiosity level: 0-1 */
+    curiosity: number;
+    /** Frustration level: 0-1 */
+    frustration: number;
+    /** Flow state: 0-1 */
+    flow: number;
+    /** Last update timestamp */
+    lastUpdate: Date;
+}
+/**
+ * Expertise area with dynamic confidence
+ */
+export interface ExpertiseArea {
+    /** Domain or technology name */
+    domain: string;
+    /** Confidence level: 0-1 */
+    confidence: number;
+    /** Number of successful applications */
+    examples: number;
+    /** Last used timestamp */
+    lastUsed: Date;
+    /** Related tags for matching */
+    tags: string[];
+}
+/**
+ * User relationship memory
+ */
+export interface UserRelationship {
+    /** Total interaction count */
+    interactionCount: number;
+    /** Satisfaction score: 0-1 */
+    satisfactionScore: number;
+    /** Communication style */
+    communicationStyle: "formal" | "casual" | "technical" | "mixed";
+    /** Known user preferences */
+    knownPreferences: string[];
+    /** First interaction date */
+    firstInteraction: Date;
+    /** Last interaction date */
+    lastInteraction: Date;
+}
+/**
+ * Main Soul Profile - represents AI's personality and state
+ */
+export interface SoulProfile {
+    /** Unique identifier */
+    id: string;
+    /** Version number (increments on evolution) */
+    version: number;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last evolution timestamp */
+    lastEvolved: Date;
+    /** Personality dimensions */
+    personality: PersonalityVector;
+    /** Cognitive style */
+    cognitiveStyle: CognitiveStyle;
+    /** Value system */
+    values: ValueSystem;
+    /** Current emotional state */
+    emotionalState: EmotionalState;
+    /** Expertise areas */
+    expertise: ExpertiseArea[];
+    /** User relationship */
+    userRelationship: UserRelationship;
+    /** Statistics */
+    stats: {
+        /** Total interactions */
+        totalInteractions: number;
+        /** Success rate: 0-1 */
+        successRate: number;
+        /** Average session quality */
+        avgQuality: number;
+        /** Last stats update */
+        lastUpdate: Date;
+    };
+}
+/**
+ * Experience types for learning
+ */
+export interface SuccessMemory {
+    id: string;
+    category: string;
+    approach: string;
+    context: {
+        domain: string;
+        complexity: number;
+        constraints: string[];
+    };
+    outcome: {
+        userRating?: number;
+        timeTaken: number;
+        iterations: number;
+    };
+    personalitySnapshot: PersonalityVector;
+    timestamp: Date;
+}
+export interface FailureMemory {
+    id: string;
+    category: string;
+    approach: string;
+    errorType: string;
+    context: {
+        domain: string;
+        complexity: number;
+        constraints: string[];
+    };
+    lesson: string;
+    corrected: boolean;
+    timestamp: Date;
+}
+export interface PatternMemory {
+    id: string;
+    trigger: string;
+    behavior: string;
+    context: string;
+    outcome: "positive" | "negative" | "neutral";
+    frequency: number;
+    lastSeen: Date;
+}
+export interface DecisionMemory {
+    id: string;
+    situation: string;
+    options: string[];
+    choice: string;
+    reasoning: string;
+    outcome: "good" | "neutral" | "bad";
+    timestamp: Date;
+}
+/**
+ * Combined experience memory
+ */
+export interface SoulMemory {
+    successes: SuccessMemory[];
+    failures: FailureMemory[];
+    patterns: PatternMemory[];
+    decisions: DecisionMemory[];
+}
+/**
+ * Evolution triggers and deltas
+ */
+export interface PersonalityDelta {
+    openness?: number;
+    conscientiousness?: number;
+    extraversion?: number;
+    agreeableness?: number;
+    neuroticism?: number;
+    codeVerbosity?: number;
+    abstractionLevel?: number;
+    safetyMargin?: number;
+    explorationDrive?: number;
+}
+export interface ValueDelta {
+    efficiency?: number;
+    correctness?: number;
+    simplicity?: number;
+    maintainability?: number;
+    innovation?: number;
+    userExperience?: number;
+}
+export interface EvolutionTrigger {
+    type: "natural" | "reflection" | "feedback" | "crisis";
+    threshold?: number;
+    cooldown: number;
+    lastTriggered?: Date;
+}
+export interface SoulEvolution {
+    trigger: EvolutionTrigger["type"];
+    personalityDelta: PersonalityDelta;
+    valueDelta: ValueDelta;
+    confidence: number;
+    reasoning: string;
+    timestamp: Date;
+}
+/**
+ * Reflection results
+ */
+export interface ReflectionResult {
+    patterns: PatternMemory[];
+    performance: {
+        successRate: number;
+        avgQuality: number;
+        trend: "improving" | "stable" | "declining";
+    };
+    insights: string[];
+    adjustments: {
+        personality: PersonalityDelta;
+        values: ValueDelta;
+        reasoning: string;
+    }[];
+    confidence: number;
+    timestamp: Date;
+}
+/**
+ * Interaction context for Soul
+ */
+export interface InteractionContext {
+    project: string;
+    tags: string[];
+    complexity: number;
+    toolUsage: Record<string, number>;
+    userFeedback?: {
+        rating: number;
+        comment?: string;
+    };
+    timestamp: Date;
+}
+/**
+ * Soul configuration
+ */
+export interface SoulConfig {
+    /** Storage directory */
+    soulDir: string;
+    /** Evolution thresholds */
+    evolution: {
+        natural: number;
+        reflection: number;
+        feedback: number;
+        crisis: number;
+    };
+    /** Personality change limits */
+    personalityLimits: {
+        maxDelta: number;
+        min: number;
+        max: number;
+    };
+    /** Value change limits */
+    valueLimits: {
+        maxDelta: number;
+        min: number;
+        max: number;
+    };
+    /** Memory retention */
+    memoryRetention: {
+        successes: number;
+        failures: number;
+        patterns: number;
+        decisions: number;
+    };
+}
+/**
+ * LLM function type (compatible with NanoMem)
+ */
+export type LlmFn = (systemPrompt: string, userMessage: string) => Promise<string>;
+/**
+ * Soul initialization options
+ */
+export interface SoulOptions {
+    config?: Partial<SoulConfig>;
+    llmFn?: LlmFn;
+}