@simonfestl/husky-cli 1.6.5 → 1.8.2

package/dist/lib/agent-identity.js

@@ -0,0 +1,73 @@
+/**
+ * Agent Identity Resolution
+ *
+ * Resolves agent identity for learnings and brain operations.
+ * Priority: workerId (config) > HUSKY_AGENT_ID (env) > session-based ID (fallback)
+ */
+import { getConfig } from '../commands/config.js';
+import { isValidAgentType } from './biz/agent-brain.js';
+import { randomUUID } from 'crypto';
+import * as os from 'os';
+let sessionAgentId;
+/**
+ * Get session-based agent ID (created once per CLI session)
+ */
+function getSessionAgentId() {
+    if (!sessionAgentId) {
+        const hostname = os.hostname();
+        const timestamp = Date.now().toString(36);
+        const random = randomUUID().split('-')[0];
+        sessionAgentId = `session-${hostname}-${timestamp}-${random}`;
+    }
+    return sessionAgentId;
+}
+/**
+ * Resolve agent identity from config, env, or generate session ID
+ */
+export function resolveAgentIdentity() {
+    const config = getConfig();
+    // Priority 1: workerId from config (persistent)
+    if (config.workerId) {
+        const agentType = config.agentType && isValidAgentType(config.agentType)
+            ? config.agentType
+            : undefined;
+        return {
+            agentId: config.workerId,
+            agentType,
+            source: 'config',
+            workerId: config.workerId,
+        };
+    }
+    // Priority 2: HUSKY_AGENT_ID from environment
+    const envAgentId = process.env.HUSKY_AGENT_ID;
+    if (envAgentId) {
+        const envAgentType = process.env.HUSKY_AGENT_TYPE;
+        const agentType = envAgentType && isValidAgentType(envAgentType)
+            ? envAgentType
+            : undefined;
+        return {
+            agentId: envAgentId,
+            agentType,
+            source: 'env',
+        };
+    }
+    // Priority 3: Session-based ID (fallback)
+    const sessionId = getSessionAgentId();
+    return {
+        agentId: sessionId,
+        agentType: undefined,
+        source: 'session',
+    };
+}
+/**
+ * Get agent ID (convenience method)
+ */
+export function getAgentId() {
+    return resolveAgentIdentity().agentId;
+}
+/**
+ * Get agent type (convenience method)
+ */
+export function getAgentType() {
+    return resolveAgentIdentity().agentType;
+}

package/dist/lib/biz/agent-brain.d.ts

@@ -1,5 +1,6 @@
 export declare const AGENT_TYPES: readonly ["support", "claude", "gotess", "supervisor", "worker"];
 export type AgentType = typeof AGENT_TYPES[number];
+export type MemoryVisibility = 'private' | 'team' | 'public';
 export interface Memory {
     id: string;
     agent: string;
@@ -9,6 +10,17 @@ export interface Memory {
     createdAt: Date;
     updatedAt: Date;
     metadata?: Record<string, unknown>;
+    visibility?: MemoryVisibility;
+    publishedBy?: string;
+    publishedAt?: string;
+    useCount?: number;
+    endorsements?: number;
+    recallCount?: number;
+    lastRecalledAt?: string;
+    boostCount?: number;
+    downvoteCount?: number;
+    qualityScore?: number;
+    status?: 'active' | 'archived' | 'deleted';
 }
 export interface RecallResult {
     memory: Memory;
@@ -32,7 +44,7 @@ export declare class AgentBrain {
         databaseName: string;
     };
     private ensureCollection;
-    remember(content: string, tags?: string[], metadata?: Record<string, unknown>): Promise<string>;
+    remember(content: string, tags?: string[], metadata?: Record<string, unknown>, visibility?: MemoryVisibility, allowPii?: boolean): Promise<string>;
     recall(query: string, limit?: number, minScore?: number): Promise<RecallResult[]>;
     recallByTags(tags: string[], limit?: number): Promise<Memory[]>;
     forget(memoryId: string): Promise<void>;
@@ -41,5 +53,55 @@ export declare class AgentBrain {
         count: number;
         tags: Record<string, number>;
     }>;
+    /**
+     * Publish a memory for sharing
+     */
+    publish(memoryId: string, visibility: MemoryVisibility): Promise<void>;
+    /**
+     * Unpublish a memory (set to private)
+     */
+    unpublish(memoryId: string): Promise<void>;
+    /**
+     * Recall shared memories from other agents
+     */
+    recallShared(query: string, limit?: number, minScore?: number, publicOnly?: boolean): Promise<RecallResult[]>;
+    /**
+     * List shared memories
+     */
+    listShared(limit?: number, publicOnly?: boolean): Promise<Memory[]>;
+    /**
+     * Boost a memory (positive feedback)
+     */
+    boost(memoryId: string): Promise<void>;
+    /**
+     * Downvote a memory (negative feedback)
+     */
+    downvote(memoryId: string): Promise<void>;
+    /**
+     * Get quality metrics for a memory
+     */
+    getQuality(memoryId: string): Promise<{
+        recallCount: number;
+        boostCount: number;
+        downvoteCount: number;
+        qualityScore: number;
+        status: string;
+    }>;
+    /**
+     * Calculate quality score based on feedback
+     */
+    private calculateQualityScore;
+    /**
+     * Calculate effective score with decay
+     */
+    private calculateEffectiveScore;
+    /**
+     * Archive low-quality memories
+     */
+    cleanup(dryRun?: boolean, threshold?: number, minAgeDays?: number, tags?: string[]): Promise<Memory[]>;
+    /**
+     * Permanently delete archived memories
+     */
+    purge(retentionDays?: number): Promise<number>;
 }
 export default AgentBrain;

package/dist/lib/biz/agent-brain.js

@@ -2,6 +2,7 @@ import { QdrantClient } from './qdrant.js';
 import { EmbeddingService } from './embeddings.js';
 import { getConfig } from '../../commands/config.js';
 import { randomUUID } from 'crypto';
+import { sanitizeForEmbedding } from './pii-filter.js';
 const MEMORIES_COLLECTION = 'agent-memories';
 const VECTOR_SIZE = 768;
 export const AGENT_TYPES = ['support', 'claude', 'gotess', 'supervisor', 'worker'];
@@ -57,19 +58,42 @@ export class AgentBrain {
             await this.qdrant.createCollection(MEMORIES_COLLECTION, VECTOR_SIZE);
         }
     }
-    async remember(content, tags = [], metadata) {
+    async remember(content, tags = [], metadata, visibility = 'private', allowPii = false) {
         await this.ensureCollection();
-        const embedding = await this.embeddings.embed(content);
+        // Phase 5: PII Filter (GDPR compliance)
+        const sanitizeResult = sanitizeForEmbedding(content, allowPii);
+        if (sanitizeResult.redactionCount > 0 && !allowPii) {
+            console.warn(`  ⚠️  PII removed from memory content (${sanitizeResult.redactedTypes.join(', ')})`);
+        }
+        // Use sanitized content for embedding (privacy-safe)
+        const embedding = await this.embeddings.embed(sanitizeResult.sanitized);
         const id = randomUUID();
         const now = new Date().toISOString();
         await this.qdrant.upsertOne(MEMORIES_COLLECTION, id, embedding, {
             agent: this.agentId,
             agentType: this.agentType || 'default',
-            content,
+            content: sanitizeResult.sanitized, // Store sanitized content
             tags,
-            metadata: metadata || {},
+            metadata: {
+                ...(metadata || {}),
+                // Store redaction info for transparency
+                piiRedacted: sanitizeResult.redactionCount > 0,
+                piiTypes: sanitizeResult.redactedTypes,
+            },
             createdAt: now,
             updatedAt: now,
+            // Phase 2: Visibility
+            visibility,
+            publishedBy: visibility !== 'private' ? this.agentId : undefined,
+            publishedAt: visibility !== 'private' ? now : undefined,
+            useCount: 0,
+            endorsements: 0,
+            // Phase 3: Quality
+            recallCount: 0,
+            boostCount: 0,
+            downvoteCount: 0,
+            qualityScore: 1.0,
+            status: 'active',
         });
         return id;
     }
@@ -195,5 +219,293 @@ export class AgentBrain {
             tags: tagCounts,
         };
     }
+    // =========================================================================
+    // Phase 2: Cross-Agent Sharing
+    // =========================================================================
+    /**
+     * Publish a memory for sharing
+     */
+    async publish(memoryId, visibility) {
+        await this.ensureCollection();
+        const now = new Date().toISOString();
+        await this.qdrant.setPayload(MEMORIES_COLLECTION, memoryId, {
+            visibility,
+            publishedBy: this.agentId,
+            publishedAt: now,
+            updatedAt: now,
+        });
+    }
+    /**
+     * Unpublish a memory (set to private)
+     */
+    async unpublish(memoryId) {
+        await this.ensureCollection();
+        const now = new Date().toISOString();
+        await this.qdrant.setPayload(MEMORIES_COLLECTION, memoryId, {
+            visibility: 'private',
+            publishedBy: undefined,
+            publishedAt: undefined,
+            updatedAt: now,
+        });
+    }
+    /**
+     * Recall shared memories from other agents
+     */
+    async recallShared(query, limit = 5, minScore = 0.5, publicOnly = false) {
+        await this.ensureCollection();
+        const queryEmbedding = await this.embeddings.embed(query);
+        const filter = {
+            must: [
+                {
+                    should: publicOnly
+                        ? [{ key: 'visibility', match: { value: 'public' } }]
+                        : [
+                            { key: 'visibility', match: { value: 'public' } },
+                            ...(this.agentType
+                                ? [{ key: 'visibility', match: { value: 'team' } }, { key: 'agentType', match: { value: this.agentType } }]
+                                : []),
+                        ],
+                },
+                { key: 'status', match: { value: 'active' } },
+            ],
+        };
+        const results = await this.qdrant.search(MEMORIES_COLLECTION, queryEmbedding, limit * 3, {
+            filter,
+            scoreThreshold: minScore,
+        });
+        return results.slice(0, limit).map(r => ({
+            memory: {
+                id: String(r.id),
+                agent: String(r.payload?.agent || ''),
+                agentType: String(r.payload?.agentType || ''),
+                content: String(r.payload?.content || ''),
+                tags: r.payload?.tags || [],
+                createdAt: new Date(String(r.payload?.createdAt || new Date().toISOString())),
+                updatedAt: new Date(String(r.payload?.updatedAt || new Date().toISOString())),
+                metadata: r.payload?.metadata,
+                visibility: r.payload?.visibility || 'private',
+                publishedBy: String(r.payload?.publishedBy || ''),
+                publishedAt: String(r.payload?.publishedAt || ''),
+                useCount: Number(r.payload?.useCount || 0),
+                endorsements: Number(r.payload?.endorsements || 0),
+            },
+            score: r.score,
+        }));
+    }
+    /**
+     * List shared memories
+     */
+    async listShared(limit = 20, publicOnly = false) {
+        await this.ensureCollection();
+        const filter = {
+            must: [
+                {
+                    should: publicOnly
+                        ? [{ key: 'visibility', match: { value: 'public' } }]
+                        : [
+                            { key: 'visibility', match: { value: 'public' } },
+                            ...(this.agentType
+                                ? [{ key: 'visibility', match: { value: 'team' } }, { key: 'agentType', match: { value: this.agentType } }]
+                                : []),
+                        ],
+                },
+                { key: 'status', match: { value: 'active' } },
+            ],
+        };
+        const results = await this.qdrant.scroll(MEMORIES_COLLECTION, {
+            filter,
+            limit,
+            with_payload: true,
+        });
+        return results
+            .map(r => ({
+            id: String(r.id),
+            agent: String(r.payload?.agent || ''),
+            agentType: String(r.payload?.agentType || ''),
+            content: String(r.payload?.content || ''),
+            tags: r.payload?.tags || [],
+            createdAt: new Date(String(r.payload?.createdAt || new Date().toISOString())),
+            updatedAt: new Date(String(r.payload?.updatedAt || new Date().toISOString())),
+            metadata: r.payload?.metadata,
+            visibility: r.payload?.visibility || 'private',
+            endorsements: Number(r.payload?.endorsements || 0),
+        }))
+            .sort((a, b) => (b.endorsements || 0) - (a.endorsements || 0));
+    }
+    // =========================================================================
+    // Phase 3: Quality & Decay
+    // =========================================================================
+    /**
+     * Boost a memory (positive feedback)
+     */
+    async boost(memoryId) {
+        await this.ensureCollection();
+        const point = await this.qdrant.getPoint(MEMORIES_COLLECTION, memoryId);
+        if (!point)
+            throw new Error('Memory not found');
+        const boostCount = Number(point.payload?.boostCount || 0) + 1;
+        const downvoteCount = Number(point.payload?.downvoteCount || 0);
+        const qualityScore = this.calculateQualityScore(boostCount, downvoteCount);
+        await this.qdrant.setPayload(MEMORIES_COLLECTION, memoryId, {
+            boostCount,
+            qualityScore,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    /**
+     * Downvote a memory (negative feedback)
+     */
+    async downvote(memoryId) {
+        await this.ensureCollection();
+        const point = await this.qdrant.getPoint(MEMORIES_COLLECTION, memoryId);
+        if (!point)
+            throw new Error('Memory not found');
+        const boostCount = Number(point.payload?.boostCount || 0);
+        const downvoteCount = Number(point.payload?.downvoteCount || 0) + 1;
+        const qualityScore = this.calculateQualityScore(boostCount, downvoteCount);
+        await this.qdrant.setPayload(MEMORIES_COLLECTION, memoryId, {
+            downvoteCount,
+            qualityScore,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    /**
+     * Get quality metrics for a memory
+     */
+    async getQuality(memoryId) {
+        await this.ensureCollection();
+        const point = await this.qdrant.getPoint(MEMORIES_COLLECTION, memoryId);
+        if (!point)
+            throw new Error('Memory not found');
+        return {
+            recallCount: Number(point.payload?.recallCount || 0),
+            boostCount: Number(point.payload?.boostCount || 0),
+            downvoteCount: Number(point.payload?.downvoteCount || 0),
+            qualityScore: Number(point.payload?.qualityScore || 1.0),
+            status: String(point.payload?.status || 'active'),
+        };
+    }
+    /**
+     * Calculate quality score based on feedback
+     */
+    calculateQualityScore(boostCount, downvoteCount) {
+        // Feedback adjustment: -0.2 to +0.2
+        const feedbackBoost = Math.tanh((boostCount - downvoteCount * 2) * 0.1) * 0.2;
+        return Math.max(0.1, Math.min(1.5, 1.0 + feedbackBoost));
+    }
+    /**
+     * Calculate effective score with decay
+     */
+    calculateEffectiveScore(semanticScore, createdAt, recallCount, boostCount, downvoteCount) {
+        const now = Date.now();
+        const ageDays = (now - createdAt.getTime()) / (1000 * 60 * 60 * 24);
+        // Exponential decay with agent-type-specific half-life
+        // Support agents: 14-day half-life (faster decay for time-sensitive support knowledge)
+        // Other agents: 30-day half-life (standard decay)
+        const halfLifeDays = this.agentType === 'support' ? 14 : 30;
+        const decayFactor = Math.pow(0.5, ageDays / halfLifeDays);
+        // Recall boost (logarithmic)
+        const recallBoost = Math.log2(recallCount + 1) * 0.1;
+        // Feedback adjustment
+        const feedbackBoost = Math.tanh((boostCount - downvoteCount * 2) * 0.1) * 0.2;
+        // Effective score
+        return semanticScore * Math.max(0.1, Math.min(1.5, decayFactor + recallBoost + feedbackBoost));
+    }
+    /**
+     * Archive low-quality memories
+     */
+    async cleanup(dryRun = true, threshold = 0.1, minAgeDays = 90, tags) {
+        await this.ensureCollection();
+        const filter = {
+            must: [
+                { key: 'agent', match: { value: this.agentId } },
+                { key: 'status', match: { value: 'active' } },
+            ],
+        };
+        if (this.agentType) {
+            filter.must.push({ key: 'agentType', match: { value: this.agentType } });
+        }
+        // Add tag filter if specified
+        if (tags && tags.length > 0) {
+            filter.must.push({
+                should: tags.map(tag => ({
+                    key: 'tags',
+                    match: { any: [tag] }
+                }))
+            });
+        }
+        const results = await this.qdrant.scroll(MEMORIES_COLLECTION, {
+            filter,
+            limit: 1000,
+            with_payload: true,
+        });
+        const toArchive = [];
+        const now = Date.now();
+        for (const r of results) {
+            const createdAt = new Date(String(r.payload?.createdAt || new Date().toISOString()));
+            const ageDays = (now - createdAt.getTime()) / (1000 * 60 * 60 * 24);
+            const qualityScore = Number(r.payload?.qualityScore || 1.0);
+            const recallCount = Number(r.payload?.recallCount || 0);
+            const downvoteCount = Number(r.payload?.downvoteCount || 0);
+            const boostCount = Number(r.payload?.boostCount || 0);
+            // Cleanup criteria
+            const shouldArchive = (qualityScore < threshold && ageDays > minAgeDays) ||
+                (downvoteCount > 3 && boostCount === 0) ||
+                (recallCount === 0 && ageDays > 180);
+            if (shouldArchive) {
+                toArchive.push({
+                    id: String(r.id),
+                    agent: String(r.payload?.agent || ''),
+                    agentType: String(r.payload?.agentType || ''),
+                    content: String(r.payload?.content || ''),
+                    tags: r.payload?.tags || [],
+                    createdAt,
+                    updatedAt: new Date(String(r.payload?.updatedAt || new Date().toISOString())),
+                    metadata: r.payload?.metadata,
+                    qualityScore,
+                    recallCount,
+                    downvoteCount,
+                    boostCount,
+                });
+                if (!dryRun) {
+                    await this.qdrant.setPayload(MEMORIES_COLLECTION, String(r.id), {
+                        status: 'archived',
+                        updatedAt: new Date().toISOString(),
+                    });
+                }
+            }
+        }
+        return toArchive;
+    }
+    /**
+     * Permanently delete archived memories
+     */
+    async purge(retentionDays = 365) {
+        await this.ensureCollection();
+        const filter = {
+            must: [
+                { key: 'agent', match: { value: this.agentId } },
+                { key: 'status', match: { value: 'archived' } },
+            ],
+        };
+        const results = await this.qdrant.scroll(MEMORIES_COLLECTION, {
+            filter,
+            limit: 1000,
+            with_payload: true,
+        });
+        const now = Date.now();
+        const toPurge = [];
+        for (const r of results) {
+            const updatedAt = new Date(String(r.payload?.updatedAt || new Date().toISOString()));
+            const daysSinceArchived = (now - updatedAt.getTime()) / (1000 * 60 * 60 * 24);
+            if (daysSinceArchived > retentionDays) {
+                toPurge.push(r.id);
+            }
+        }
+        if (toPurge.length > 0) {
+            await this.qdrant.deletePoints(MEMORIES_COLLECTION, toPurge);
+        }
+        return toPurge.length;
+    }
 }
 export default AgentBrain;

package/dist/lib/biz/learning-capture.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Learning Capture Service
+ *
+ * Automatically captures learnings when a task is completed.
+ * Uses LLM (Vertex AI) to extract meaningful learnings from task context.
+ */
+import { AgentType } from './agent-brain.js';
+export interface Task {
+    id: string;
+    title: string;
+    description?: string;
+    status: string;
+    priority?: string;
+    projectId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LearningCaptureInput {
+    taskId: string;
+    task: Task;
+    prUrl?: string;
+    explicitLearnings?: string;
+    agentId: string;
+    agentType?: AgentType;
+}
+export interface LearningResult {
+    id: string;
+    content: string;
+    tags: string[];
+}
+/**
+ * Capture learnings from a completed task
+ *
+ * This function:
+ * 1. Generates learnings from task context (or uses explicit learnings)
+ * 2. Stores them in the agent's brain
+ * 3. Returns the learning IDs
+ */
+export declare function captureLearnings(input: LearningCaptureInput): Promise<LearningResult[]>;
+/**
+ * Fetch task details from API
+ */
+export declare function fetchTask(taskId: string, apiUrl: string, apiKey?: string): Promise<Task | null>;

package/dist/lib/biz/learning-capture.js

@@ -0,0 +1,107 @@
+/**
+ * Learning Capture Service
+ *
+ * Automatically captures learnings when a task is completed.
+ * Uses LLM (Vertex AI) to extract meaningful learnings from task context.
+ */
+import { AgentBrain } from './agent-brain.js';
+/**
+ * Generate learnings from task context using LLM
+ */
+async function generateLearningsFromTask(task, prUrl) {
+    // For now, return basic task-based learnings
+    // TODO: In future, use Vertex AI to extract deeper insights from:
+    // - Task description
+    // - PR diff/content
+    // - Related comments/discussions
+    // - Error patterns encountered
+    const learnings = [];
+    // Basic learning from task completion
+    const basicTags = [
+        `task:${task.id}`,
+        ...(task.projectId ? [`project:${task.projectId}`] : []),
+        'type:completion',
+    ];
+    // Create a learning from the task
+    const taskLearning = {
+        content: `Completed task: ${task.title}${task.description ? ` - ${task.description}` : ''}${prUrl ? ` (PR: ${prUrl})` : ''}`,
+        tags: basicTags,
+    };
+    learnings.push(taskLearning);
+    return learnings;
+}
+/**
+ * Capture learnings from a completed task
+ *
+ * This function:
+ * 1. Generates learnings from task context (or uses explicit learnings)
+ * 2. Stores them in the agent's brain
+ * 3. Returns the learning IDs
+ */
+export async function captureLearnings(input) {
+    const { taskId, task, prUrl, explicitLearnings, agentId, agentType } = input;
+    // Initialize agent brain
+    const brain = new AgentBrain({ agentId, agentType });
+    const results = [];
+    // If explicit learnings provided, store them directly
+    if (explicitLearnings) {
+        const tags = [
+            `task:${taskId}`,
+            ...(task.projectId ? [`project:${task.projectId}`] : []),
+            'type:explicit',
+            'source:manual',
+        ];
+        const id = await brain.remember(explicitLearnings, tags, {
+            taskId,
+            taskTitle: task.title,
+            prUrl,
+            capturedAt: new Date().toISOString(),
+        });
+        results.push({
+            id,
+            content: explicitLearnings,
+            tags,
+        });
+        return results;
+    }
+    // Generate learnings from task context
+    try {
+        const generatedLearnings = await generateLearningsFromTask(task, prUrl);
+        for (const learning of generatedLearnings) {
+            const id = await brain.remember(learning.content, learning.tags, {
+                taskId,
+                taskTitle: task.title,
+                prUrl,
+                capturedAt: new Date().toISOString(),
+                source: 'auto-generated',
+            });
+            results.push({
+                id,
+                content: learning.content,
+                tags: learning.tags,
+            });
+        }
+    }
+    catch (error) {
+        console.warn('  ⚠️  Failed to generate learnings:', error instanceof Error ? error.message : error);
+        // Don't fail task completion if learning capture fails
+    }
+    return results;
+}
+/**
+ * Fetch task details from API
+ */
+export async function fetchTask(taskId, apiUrl, apiKey) {
+    try {
+        const res = await fetch(`${apiUrl}/api/tasks/${taskId}`, {
+            headers: apiKey ? { 'x-api-key': apiKey } : {},
+        });
+        if (!res.ok) {
+            return null;
+        }
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/biz/pii-filter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * PII Filter for GDPR-Compliant Embeddings
+ *
+ * Sanitizes content before embedding to remove personally identifiable information (PII).
+ * This enables:
+ * - DSGVO/GDPR compliance
+ * - Use of US-hosted models (OpenAI, Anthropic US)
+ * - Automatic SOP generation from learnings
+ * - Unlimited retention (no Löschrecht)
+ */
+export interface SanitizeResult {
+    sanitized: string;
+    redactedTypes: string[];
+    redactionCount: number;
+}
+/**
+ * Sanitize content by removing PII
+ */
+export declare function sanitizeForEmbedding(content: string, allowPii?: boolean): SanitizeResult;
+/**
+ * Check if content contains PII
+ */
+export declare function containsPII(content: string): boolean;
+/**
+ * Preview what would be redacted (for debugging)
+ */
+export declare function previewRedaction(content: string): {
+    original: string;
+    sanitized: string;
+    changes: Array<{
+        type: string;
+        count: number;
+    }>;
+};