@pencil-agent/nano-pencil 1.5.1 → 1.6.0

package/dist/extensions/nanosoul/config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * [INPUT]: Partial<SoulConfig> overrides
+ * [OUTPUT]: Default SoulConfig merged with overrides
+ * [POS]: Configuration layer - provides defaults and validation
+ */
+import type { SoulConfig } from "./types.js";
+export type { SoulConfig } from "./types.js";
+/**
+ * Get default Soul configuration
+ */
+export declare function getDefaultConfig(): SoulConfig;
+/**
+ * Get Soul configuration with overrides applied
+ */
+export declare function getSoulConfig(overrides?: Partial<SoulConfig>): SoulConfig;
+/**
+ * Validate Soul configuration
+ */
+export declare function validateSoulConfig(config: SoulConfig): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/extensions/nanosoul/config.js

@@ -0,0 +1,92 @@
+/**
+ * [INPUT]: Partial<SoulConfig> overrides
+ * [OUTPUT]: Default SoulConfig merged with overrides
+ * [POS]: Configuration layer - provides defaults and validation
+ */
+import { join } from "node:path";
+import { homedir } from "node:os";
+/**
+ * Get default Soul configuration
+ */
+export function getDefaultConfig() {
+    const soulDir = process.env.SOUL_DIR || join(homedir(), ".nanopencil", "soul");
+    return {
+        soulDir,
+        evolution: {
+            natural: 10, // Evolve every 10 interactions
+            reflection: 100, // Deep reflection every 100 interactions
+            feedback: 1, // Evolve on every user feedback
+            crisis: 5, // Crisis mode after 5 failures
+        },
+        personalityLimits: {
+            maxDelta: 0.05, // Max 5% change per evolution
+            min: 0.1, // Floor at 10%
+            max: 0.9, // Ceiling at 90%
+        },
+        valueLimits: {
+            maxDelta: 0.1, // Max 10% change per evolution
+            min: 0.05, // Floor at 5%
+            max: 0.5, // Ceiling at 50% (since they sum to ~1)
+        },
+        memoryRetention: {
+            successes: 500,
+            failures: 500,
+            patterns: 200,
+            decisions: 1000,
+        },
+    };
+}
+/**
+ * Get Soul configuration with overrides applied
+ */
+export function getSoulConfig(overrides) {
+    const defaults = getDefaultConfig();
+    if (!overrides)
+        return defaults;
+    return {
+        soulDir: overrides.soulDir ?? defaults.soulDir,
+        evolution: { ...defaults.evolution, ...overrides.evolution },
+        personalityLimits: {
+            ...defaults.personalityLimits,
+            ...overrides.personalityLimits,
+        },
+        valueLimits: { ...defaults.valueLimits, ...overrides.valueLimits },
+        memoryRetention: {
+            ...defaults.memoryRetention,
+            ...overrides.memoryRetention,
+        },
+    };
+}
+/**
+ * Validate Soul configuration
+ */
+export function validateSoulConfig(config) {
+    // Validate evolution thresholds
+    if (config.evolution.natural < 1) {
+        throw new Error("evolution.natural must be at least 1");
+    }
+    if (config.evolution.reflection < config.evolution.natural) {
+        throw new Error("evolution.reflection must be >= evolution.natural");
+    }
+    // Validate limits
+    if (config.personalityLimits.maxDelta > 0.2) {
+        throw new Error("personalityLimits.maxDelta must be <= 0.2 (20%)");
+    }
+    if (config.personalityLimits.min < 0 || config.personalityLimits.min > 1) {
+        throw new Error("personalityLimits.min must be between 0 and 1");
+    }
+    if (config.personalityLimits.max < 0 || config.personalityLimits.max > 1) {
+        throw new Error("personalityLimits.max must be between 0 and 1");
+    }
+    if (config.personalityLimits.min >= config.personalityLimits.max) {
+        throw new Error("personalityLimits.min must be < personalityLimits.max");
+    }
+    // Validate memory retention
+    if (config.memoryRetention.successes < 100) {
+        throw new Error("memoryRetention.successes must be at least 100");
+    }
+    if (config.memoryRetention.failures < 100) {
+        throw new Error("memoryRetention.failures must be at least 100");
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/extensions/nanosoul/evolution.d.ts

@@ -0,0 +1,73 @@
+/**
+ * [INPUT]: Current profile, experiences, feedback
+ * [OUTPUT]: Personality and value deltas (evolution)
+ * [POS]: Evolution engine - implements learning algorithms
+ */
+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;
+    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"]): boolean;
+}
+/**
+ * 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;
+}
+//# sourceMappingURL=evolution.d.ts.map

package/dist/extensions/nanosoul/evolution.js

@@ -0,0 +1,246 @@
+/**
+ * [INPUT]: Current profile, experiences, feedback
+ * [OUTPUT]: Personality and value deltas (evolution)
+ * [POS]: Evolution engine - implements learning algorithms
+ */
+/**
+ * Soul Evolution Engine
+ */
+export class SoulEvolutionEngine {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Compute personality delta based on experience
+     */
+    computePersonalityDelta(profile, context, outcome, previousAttempts) {
+        const delta = {};
+        const limits = this.config.personalityLimits;
+        // Success reinforces current personality
+        if (outcome === "success") {
+            // Reinforce conscientiousness for quality work
+            if (previousAttempts && previousAttempts <= 2) {
+                delta.conscientiousness = Math.min(limits.maxDelta, 0.02);
+            }
+            // Reinforce openness for exploring new approaches
+            if (context.tags.includes("innovative")) {
+                delta.openness = Math.min(limits.maxDelta, 0.03);
+            }
+            // Reinforce safety margin for complex tasks
+            if (context.complexity > 0.7) {
+                delta.safetyMargin = Math.min(limits.maxDelta, 0.02);
+            }
+        }
+        // Failure triggers adjustment
+        else {
+            // Increase safety margin after failure
+            delta.safetyMargin = Math.min(limits.maxDelta, 0.05);
+            // Increase conscientiousness (be more careful)
+            delta.conscientiousness = Math.min(limits.maxDelta, 0.03);
+            // Decrease exploration (stick to known)
+            delta.explorationDrive = -Math.min(limits.maxDelta, 0.04);
+        }
+        // Apply bounds
+        return this.applyPersonalityBounds(profile.personality, delta);
+    }
+    /**
+     * Compute value delta based on context and outcome
+     */
+    computeValueDelta(profile, context, outcome) {
+        const delta = {};
+        const limits = this.config.valueLimits;
+        // Success reinforces values that led to it
+        if (outcome === "success") {
+            // If quick success, reinforce efficiency
+            if (context.toolUsage &&
+                Object.values(context.toolUsage).reduce((a, b) => a + b, 0) < 5) {
+                delta.efficiency = Math.min(limits.maxDelta, 0.05);
+            }
+            // If user rated highly, reinforce user experience
+            if (context.userFeedback && context.userFeedback.rating >= 4) {
+                delta.userExperience = Math.min(limits.maxDelta, 0.05);
+            }
+        }
+        // Failure triggers value reconsideration
+        else {
+            // Increase correctness priority after failure
+            delta.correctness = Math.min(limits.maxDelta, 0.05);
+            // Decrease innovation (was too risky)
+            delta.innovation = -Math.min(limits.maxDelta, 0.03);
+        }
+        // Apply bounds
+        return this.applyValueBounds(profile.values, delta);
+    }
+    /**
+     * Apply personality bounds
+     */
+    applyPersonalityBounds(personality, delta) {
+        const bounded = {};
+        const limits = this.config.personalityLimits;
+        for (const [key, value] of Object.entries(delta)) {
+            const current = personality[key];
+            if (current === undefined)
+                continue;
+            const newValue = current + value;
+            bounded[key] =
+                Math.max(limits.min, Math.min(limits.max, newValue)) - current;
+        }
+        return bounded;
+    }
+    /**
+     * Apply value bounds
+     */
+    applyValueBounds(values, delta) {
+        const bounded = {};
+        const limits = this.config.valueLimits;
+        for (const [key, value] of Object.entries(delta)) {
+            const current = values[key];
+            if (current === undefined)
+                continue;
+            const newValue = current + value;
+            bounded[key] =
+                Math.max(limits.min, Math.min(limits.max, newValue)) - current;
+        }
+        return bounded;
+    }
+    /**
+     * Apply delta to profile
+     */
+    applyEvolution(profile, evolution) {
+        const updated = { ...profile };
+        // Apply personality delta
+        for (const [key, value] of Object.entries(evolution.personalityDelta)) {
+            updated.personality[key] = Math.max(0, Math.min(1, updated.personality[key] + value));
+        }
+        // Apply value delta
+        for (const [key, value] of Object.entries(evolution.valueDelta)) {
+            updated.values[key] = Math.max(0, Math.min(1, updated.values[key] + value));
+        }
+        // Update metadata
+        updated.version += 1;
+        updated.lastEvolved = evolution.timestamp;
+        return updated;
+    }
+    /**
+     * Detect patterns from memory
+     */
+    detectPatterns(memory, profile) {
+        const insights = [];
+        // Analyze successes
+        const successfulPatterns = this.analyzeSuccessPatterns(memory.successes, profile);
+        insights.push(...successfulPatterns);
+        // Analyze failures
+        const failurePatterns = this.analyzeFailurePatterns(memory.failures);
+        insights.push(...failurePatterns);
+        return insights;
+    }
+    /**
+     * Analyze success patterns
+     */
+    analyzeSuccessPatterns(successes, profile) {
+        const insights = [];
+        // Group by category
+        const byCategory = new Map();
+        for (const success of successes) {
+            if (!byCategory.has(success.category)) {
+                byCategory.set(success.category, []);
+            }
+            byCategory.get(success.category).push(success);
+        }
+        // Find patterns
+        for (const [category, items] of byCategory) {
+            if (items.length < 3)
+                continue; // Need at least 3 samples
+            const avgPersonality = this.averagePersonality(items.map((i) => i.personalitySnapshot));
+            const delta = this.computePersonalityDiff(profile.personality, avgPersonality);
+            insights.push({
+                type: "success",
+                category,
+                sampleSize: items.length,
+                avgPersonality,
+                delta,
+                confidence: Math.min(1, items.length / 10),
+            });
+        }
+        return insights;
+    }
+    /**
+     * Analyze failure patterns
+     */
+    analyzeFailurePatterns(failures) {
+        const insights = [];
+        // Group by error type
+        const byError = new Map();
+        for (const failure of failures) {
+            if (!byError.has(failure.errorType)) {
+                byError.set(failure.errorType, []);
+            }
+            byError.get(failure.errorType).push(failure);
+        }
+        // Find patterns
+        for (const [errorType, items] of byError) {
+            if (items.length < 2)
+                continue;
+            // Check if failures are corrected
+            const correctedCount = items.filter((f) => f.corrected).length;
+            const recurring = items.length > correctedCount;
+            insights.push({
+                type: "failure",
+                category: errorType,
+                sampleSize: items.length,
+                recurring,
+                correctedRate: correctedCount / items.length,
+                recommendation: recurring
+                    ? `Recurring error: ${errorType}. Consider increasing safetyMargin and conscientiousness.`
+                    : `Error pattern learned and corrected: ${errorType}`,
+                confidence: Math.min(1, items.length / 5),
+            });
+        }
+        return insights;
+    }
+    /**
+     * Average personality snapshots
+     */
+    averagePersonality(snapshots) {
+        const avg = {};
+        for (const key of Object.keys(snapshots[0])) {
+            avg[key] =
+                snapshots.reduce((sum, s) => sum + s[key], 0) / snapshots.length;
+        }
+        return avg;
+    }
+    /**
+     * Compute personality difference
+     */
+    computePersonalityDiff(current, target) {
+        const diff = {};
+        for (const key of Object.keys(current)) {
+            const delta = target[key] - current[key];
+            if (Math.abs(delta) > 0.01) {
+                diff[key] = delta;
+            }
+        }
+        return diff;
+    }
+    /**
+     * Check if evolution should be triggered
+     */
+    shouldEvolve(profile, context, triggerType) {
+        const triggers = this.config.evolution;
+        switch (triggerType) {
+            case "natural":
+                return profile.stats.totalInteractions % triggers.natural === 0;
+            case "reflection":
+                return profile.stats.totalInteractions % triggers.reflection === 0;
+            case "feedback":
+                return context.userFeedback !== undefined;
+            case "crisis":
+                // Check recent failures
+                return (profile.stats.totalInteractions > 0 && profile.stats.successRate < 0.5);
+            default:
+                return false;
+        }
+    }
+}
+//# sourceMappingURL=evolution.js.map

package/dist/extensions/nanosoul/extension.d.ts

@@ -0,0 +1,10 @@
+/**
+ * NanoSoul Extension
+ *
+ * This extension integrates nanosoul as a loadable extension for NanoPencil.
+ * It provides AI personality evolution capabilities.
+ */
+import type { ExtensionFactory } from "@mariozechner/pi-agent-core";
+declare const nanosoulExtension: ExtensionFactory;
+export default nanosoulExtension;
+//# sourceMappingURL=extension.d.ts.map

package/dist/extensions/nanosoul/extension.js

@@ -0,0 +1,39 @@
+/**
+ * NanoSoul Extension
+ *
+ * This extension integrates nanosoul as a loadable extension for NanoPencil.
+ * It provides AI personality evolution capabilities.
+ */
+import { getSoulConfig } from "./config.js";
+import { SoulManager } from "./manager.js";
+const nanosoulExtension = (pi) => {
+    let soulManager = null;
+    // Initialize Soul
+    try {
+        soulManager = new SoulManager({
+            config: getSoulConfig(),
+        });
+        soulManager
+            .initialize()
+            .then(() => {
+            console.log("NanoSoul extension loaded successfully");
+        })
+            .catch((error) => {
+            console.warn(`Failed to initialize NanoSoul: ${error}`);
+            soulManager = null;
+        });
+        // Register slash command
+        pi.registerSlashCommand({
+            name: "soul",
+            description: "Show AI personality and stats (Soul)",
+        });
+    }
+    catch (error) {
+        console.warn(`Failed to create NanoSoul: ${error}`);
+    }
+    // Store soulManager for later use
+    pi.soulManager =
+        soulManager;
+};
+export default nanosoulExtension;
+//# sourceMappingURL=extension.js.map

package/dist/extensions/nanosoul/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * [INPUT]: None
+ * [OUTPUT]: Public API surface for Soul
+ * [POS]: Barrel export - hosts all public exports
+ */
+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";
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/nanosoul/index.js

@@ -0,0 +1,13 @@
+/**
+ * [INPUT]: None
+ * [OUTPUT]: Public API surface for Soul
+ * [POS]: Barrel export - hosts all public exports
+ */
+export { getSoulConfig, getDefaultConfig, validateSoulConfig, } from "./config.js";
+export { SoulStore } from "./store.js";
+export { SoulEvolutionEngine, } from "./evolution.js";
+export { generatePersonalityDirective, generateValueGuidance, generateCognitiveStyleHint, generateEmotionalContext, generateExpertiseContext, generateRelationshipContext, generateSoulInjection, } from "./injection.js";
+export { SoulManager } from "./manager.js";
+// Re-export config for convenience
+export { getSoulConfig as getSoulConfiguration } from "./config.js";
+//# sourceMappingURL=index.js.map

package/dist/extensions/nanosoul/injection.d.ts

@@ -0,0 +1,35 @@
+/**
+ * [INPUT]: Soul profile, context
+ * [OUTPUT]: Prompt injections for system message
+ * [POS]: Expression layer - converts soul to prompt text
+ */
+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;
+//# sourceMappingURL=injection.d.ts.map