profclaw 0.0.1-beta.1

package/dist/summaries/extractor.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Summary Extractor
+ *
+ * Extracts structured summaries from agent outputs without
+ * requiring additional AI calls (zero-cost extraction).
+ */
+import type { CreateSummaryInput, FileChange, Decision, Blocker, ArtifactReference } from '../types/summary.js';
+import type { TaskResult, TaskArtifact } from '../types/task.js';
+import type { SessionAggregate, HookInference } from '../hooks/types.js';
+export declare const FILE_CREATED_PATTERN: RegExp;
+export declare const FILE_MODIFIED_PATTERN: RegExp;
+export declare const FILE_DELETED_PATTERN: RegExp;
+export declare const COMMIT_SHA_PATTERN: RegExp;
+export declare const PR_URL_PATTERN: RegExp;
+export declare const GITHUB_ISSUE_PATTERN: RegExp;
+export declare const GENERIC_ISSUE_PATTERN: RegExp;
+export declare const BRANCH_PATTERN: RegExp;
+export declare const DECISION_PATTERNS: RegExp[];
+export declare const ERROR_PATTERN: RegExp;
+export declare const WARNING_PATTERN: RegExp;
+export declare const SUMMARY_SECTION_PATTERN: RegExp;
+export declare const WHY_SECTION_PATTERN: RegExp;
+export declare const HOW_SECTION_PATTERN: RegExp;
+/**
+ * Extract a summary from a task result
+ */
+export declare function extractFromTaskResult(result: TaskResult, context?: {
+    taskId?: string;
+    agent?: string;
+    model?: string;
+    startedAt?: Date;
+}): Promise<CreateSummaryInput>;
+/**
+ * Extract a summary from session aggregate
+ */
+export declare function extractFromSession(session: SessionAggregate, inference?: HookInference): CreateSummaryInput;
+/**
+ * Extract a summary from raw agent output
+ */
+export declare function extractFromRawOutput(output: string, context?: {
+    agent?: string;
+    model?: string;
+    taskId?: string;
+    sessionId?: string;
+}): CreateSummaryInput;
+export declare function extractFileChanges(output: string, artifacts?: TaskArtifact[]): FileChange[];
+export declare function extractDecisions(output: string): Decision[];
+export declare function extractBlockers(output: string, error?: TaskResult['error']): Blocker[];
+export declare function extractArtifacts(output: string, taskArtifacts?: TaskArtifact[]): ArtifactReference[];
+export declare function extractSection(output: string, pattern: RegExp): string | undefined;
+export declare function generateWhatChanged(files: FileChange[], artifacts: ArtifactReference[]): string;
+export declare function isValidFilePath(path: string): boolean;
+export declare function inferTaskType(output: string, files: FileChange[], title?: string): string;
+export declare function inferComponent(files: FileChange[]): string | undefined;
+export declare function generateSmartTitle(whatChanged: string, files: FileChange[], artifacts: ArtifactReference[], taskType: string): string;
+//# sourceMappingURL=extractor.d.ts.map

package/dist/summaries/extractor.js

@@ -0,0 +1,377 @@
+/**
+ * Summary Extractor
+ *
+ * Extracts structured summaries from agent outputs without
+ * requiring additional AI calls (zero-cost extraction).
+ */
+import { getSettings } from '../settings/index.js';
+import { getOllamaService } from '../intelligence/ollama.js';
+// Patterns for extraction
+export const FILE_CREATED_PATTERN = /(?:created?|added?|wrote?|new file)[:\s]+[`"']?([a-zA-Z0-9_\-\.\/]+\.[a-z0-9]+|(?:\.[a-z0-9_\-]+))[`"']?/gi;
+export const FILE_MODIFIED_PATTERN = /(?:modified?|updated?|changed?|edited?|wrote?)[:\s]+[`"']?([a-zA-Z0-9_\-\.\/]+\.[a-z0-9]+|(?:\.[a-z0-9_\-]+))[`"']?/gi;
+export const FILE_DELETED_PATTERN = /(?:deleted?|removed?)[:\s]+[`"']?([a-zA-Z0-9_\-\.\/]+\.[a-z0-9]+|(?:\.[a-z0-9_\-]+))[`"']?/gi;
+export const COMMIT_SHA_PATTERN = /\b([a-f0-9]{7,40})\b/g;
+export const PR_URL_PATTERN = /https:\/\/(?:github\.com|gitlab\.com)\/[^/]+\/[^/]+\/(?:pull|merge_requests)\/(\d+)/gi;
+export const GITHUB_ISSUE_PATTERN = /#(\d+)/g;
+export const GENERIC_ISSUE_PATTERN = /\b([A-Z]{2,10}-\d+)\b/g;
+export const BRANCH_PATTERN = /(?:branch|checkout|switch|on)[:\s]+[`"']?([a-zA-Z0-9_\-./]+)[`"']?/gi;
+export const DECISION_PATTERNS = [
+    /(?:decided?|chose?|opted?|selected?|used|implemented)(?:\s+to)?[:\s]+(.+?)(?:\.|\n|$)/gi,
+    /(?:instead of|rather than)[:\s]+(.+?)(?:,|\.|\n|$)/gi,
+];
+export const ERROR_PATTERN = /(?:error|failed?|couldn't|cannot|issue)[:\s]+(.+?)(?:\.|$)/gi;
+export const WARNING_PATTERN = /(?:warning|warn|caution)[:\s]+(.+?)(?:\.|$)/gi;
+export const SUMMARY_SECTION_PATTERN = /##?\s*(?:summary|what changed|changes)[:\s]*\n([\s\S]*?)(?=\n##|$)/i;
+export const WHY_SECTION_PATTERN = /##?\s*(?:why|motivation|reason)[:\s]*\n([\s\S]*?)(?=\n##|$)/i;
+export const HOW_SECTION_PATTERN = /##?\s*(?:how|approach|implementation)[:\s]*\n([\s\S]*?)(?=\n##|$)/i;
+const TASK_TYPE_KEYWORDS = {
+    bug_fix: ['fix', 'bug', 'issue', 'error', 'crash', 'broken', 'repair', 'patch', 'resolve'],
+    feature: ['add', 'new', 'implement', 'create', 'feature', 'introduce', 'enable'],
+    refactor: ['refactor', 'restructure', 'reorganize', 'clean', 'improve', 'simplify', 'extract'],
+    documentation: ['docs', 'documentation', 'readme', 'comment', 'jsdoc', 'typedoc', 'explain'],
+    test: ['test', 'spec', 'coverage', 'mock', 'stub', 'jest', 'vitest', 'testing'],
+    performance: ['performance', 'perf', 'speed', 'optimize', 'cache', 'lazy', 'faster', 'memory'],
+    security: ['security', 'auth', 'password', 'permission', 'vulnerability', 'xss', 'csrf', 'token', 'encrypt'],
+    chore: ['chore', 'upgrade', 'dependency', 'package', 'version', 'config', 'lint', 'build', 'gitignore'],
+};
+const COMPONENT_PATTERNS = [
+    { pattern: /\/(components?|ui)\//i, component: 'ui' },
+    { pattern: /\/(views?|pages?|screens?)\//i, component: 'views' },
+    { pattern: /\/(api|routes?|endpoints?)\//i, component: 'api' },
+    { pattern: /\/(utils?|helpers?|lib)\//i, component: 'utils' },
+    { pattern: /\/(hooks?)\//i, component: 'hooks' },
+    { pattern: /\/(store|state|redux|context)\//i, component: 'state' },
+    { pattern: /\/(types?|interfaces?)\//i, component: 'types' },
+    { pattern: /\/(tests?|specs?|__tests__)\//i, component: 'tests' },
+    { pattern: /\/(styles?|css|scss)\//i, component: 'styles' },
+    { pattern: /\/(auth|authentication|login)\//i, component: 'auth' },
+    { pattern: /\/(database|db|storage|models?)\//i, component: 'database' },
+    { pattern: /\/(config|settings)\//i, component: 'config' },
+];
+/**
+ * Extract a summary from a task result
+ */
+export async function extractFromTaskResult(result, context) {
+    const settings = await getSettings();
+    if (settings.aiProvider?.defaultProvider === 'ollama') {
+        const ollama = getOllamaService();
+        const summary = await ollama.generateSummary(result, { taskId: context?.taskId, agent: context?.agent, model: context?.model });
+        return {
+            ...summary,
+            taskId: context?.taskId,
+            agent: context?.agent || 'ollama',
+            model: context?.model,
+            rawOutput: result.output,
+        };
+    }
+    const output = result.output || '';
+    const summary = extractFromRawOutput(output, {
+        taskId: context?.taskId,
+        agent: context?.agent,
+        model: context?.model,
+    });
+    if (result.error) {
+        summary.blockers = [
+            ...(summary.blockers || []),
+            { description: result.error.message, severity: 'error', resolved: false },
+        ];
+    }
+    return summary;
+}
+/**
+ * Extract a summary from session aggregate
+ */
+export function extractFromSession(session, inference) {
+    let filesChanged = [];
+    if (session.filesCreated?.length || session.filesModified?.length) {
+        filesChanged = [
+            ...(session.filesCreated || []).map(path => ({ path, action: 'created' })),
+            ...(session.filesModified || []).map(path => ({ path, action: 'modified' }))
+        ];
+    }
+    else if (session.summary) {
+        filesChanged = extractFileChanges(session.summary);
+    }
+    const artifacts = session.summary ? extractArtifacts(session.summary) : [];
+    const whatChanged = inference?.commitMessage
+        || (session.summary ? generateWhatChanged(filesChanged, artifacts) : 'Session activity');
+    const taskType = inference?.taskType || (session.summary ? inferTaskType(session.summary, filesChanged) : 'chore');
+    const title = inference?.commitMessage || generateSmartTitle(whatChanged, filesChanged, artifacts, taskType);
+    return {
+        sessionId: session.sessionId,
+        agent: 'claude-code',
+        startedAt: session.startTime,
+        completedAt: session.endTime,
+        durationMs: session.endTime && session.startTime
+            ? session.endTime.getTime() - session.startTime.getTime()
+            : undefined,
+        title,
+        whatChanged,
+        filesChanged,
+        taskType,
+        component: inference?.component,
+        linkedIssue: inference?.linkedIssue,
+        linkedPr: inference?.linkedPr,
+    };
+}
+/**
+ * Extract a summary from raw agent output
+ */
+export function extractFromRawOutput(output, context) {
+    const filesChanged = extractFileChanges(output);
+    const decisions = extractDecisions(output);
+    const blockers = extractBlockers(output);
+    const artifacts = extractArtifacts(output);
+    const whatChanged = extractSection(output, SUMMARY_SECTION_PATTERN) ||
+        generateWhatChanged(filesChanged, artifacts);
+    const whyChanged = extractSection(output, WHY_SECTION_PATTERN);
+    const howChanged = extractSection(output, HOW_SECTION_PATTERN);
+    const taskType = inferTaskType(output, filesChanged);
+    const component = inferComponent(filesChanged);
+    const title = generateSmartTitle(whatChanged, filesChanged, artifacts, taskType);
+    const linkedPr = artifacts.find(a => a.type === 'pull_request')?.url;
+    const linkedIssue = artifacts.find(a => a.identifier && /^[A-Z]{2,10}-\d+$/.test(a.identifier))?.identifier
+        || artifacts.find(a => a.type === 'other' && a.title === 'Issue')?.identifier;
+    return {
+        taskId: context?.taskId,
+        sessionId: context?.sessionId,
+        agent: context?.agent || 'unknown',
+        model: context?.model,
+        title,
+        whatChanged,
+        whyChanged,
+        howChanged,
+        filesChanged,
+        decisions,
+        blockers,
+        artifacts,
+        taskType,
+        component,
+        linkedIssue,
+        linkedPr,
+        rawOutput: output,
+    };
+}
+export function extractFileChanges(output, artifacts) {
+    const changes = [];
+    const seen = new Set();
+    if (artifacts) {
+        for (const a of artifacts) {
+            if (a.type === 'file' && a.path && !seen.has(a.path)) {
+                seen.add(a.path);
+                changes.push({ path: a.path, action: 'modified' });
+            }
+        }
+    }
+    const addFromPattern = (pattern, action) => {
+        let match;
+        pattern.lastIndex = 0;
+        while ((match = pattern.exec(output)) !== null) {
+            const path = match[1];
+            if (path && !seen.has(path) && isValidFilePath(path)) {
+                seen.add(path);
+                changes.push({ path, action });
+            }
+        }
+    };
+    addFromPattern(FILE_CREATED_PATTERN, 'created');
+    addFromPattern(FILE_MODIFIED_PATTERN, 'modified');
+    addFromPattern(FILE_DELETED_PATTERN, 'deleted');
+    return changes;
+}
+export function extractDecisions(output) {
+    const decisions = [];
+    for (const pattern of DECISION_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(output)) !== null) {
+            const description = match[1].trim();
+            if (description.length > 5 && description.length < 500) {
+                decisions.push({ description });
+            }
+        }
+    }
+    return decisions.slice(0, 10);
+}
+export function extractBlockers(output, error) {
+    const blockers = [];
+    if (error) {
+        blockers.push({ description: error.message, severity: 'error', resolved: false });
+    }
+    ERROR_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = ERROR_PATTERN.exec(output)) !== null) {
+        const d = match[1].trim();
+        if (d.length > 2)
+            blockers.push({ description: d, severity: 'error', resolved: true });
+    }
+    WARNING_PATTERN.lastIndex = 0;
+    while ((match = WARNING_PATTERN.exec(output)) !== null) {
+        const d = match[1].trim();
+        if (d.length > 2)
+            blockers.push({ description: d, severity: 'warning', resolved: true });
+    }
+    return blockers.slice(0, 10);
+}
+export function extractArtifacts(output, taskArtifacts) {
+    const artifacts = [];
+    const seen = new Set();
+    if (taskArtifacts) {
+        for (const a of taskArtifacts) {
+            const key = `${a.type}:${a.url || a.sha || a.path}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                artifacts.push({ type: a.type, url: a.url, identifier: a.sha });
+            }
+        }
+    }
+    PR_URL_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = PR_URL_PATTERN.exec(output)) !== null) {
+        const key = `pr:${match[1]}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            artifacts.push({ type: 'pull_request', url: match[0], identifier: match[1] });
+        }
+    }
+    COMMIT_SHA_PATTERN.lastIndex = 0;
+    while ((match = COMMIT_SHA_PATTERN.exec(output)) !== null) {
+        const sha = match[1];
+        if (sha.length >= 7 && !seen.has(`commit:${sha}`)) {
+            seen.add(`commit:${sha}`);
+            artifacts.push({ type: 'commit', identifier: sha });
+        }
+    }
+    GENERIC_ISSUE_PATTERN.lastIndex = 0;
+    while ((match = GENERIC_ISSUE_PATTERN.exec(output)) !== null) {
+        const issueId = match[1];
+        if (!seen.has(`issue:${issueId}`)) {
+            seen.add(`issue:${issueId}`);
+            artifacts.push({ type: 'other', identifier: issueId, title: 'Issue' });
+        }
+    }
+    return artifacts;
+}
+export function extractSection(output, pattern) {
+    const match = output.match(pattern);
+    return match && match[1] ? match[1].trim().slice(0, 1000) : undefined;
+}
+export function generateWhatChanged(files, artifacts) {
+    const parts = [];
+    const created = files.filter(f => f.action === 'created');
+    const modified = files.filter(f => f.action === 'modified');
+    const deleted = files.filter(f => f.action === 'deleted');
+    if (created.length > 0)
+        parts.push(`Created ${created.length} file(s)`);
+    if (modified.length > 0)
+        parts.push(`Modified ${modified.length} file(s)`);
+    if (deleted.length > 0)
+        parts.push(`Deleted ${deleted.length} file(s)`);
+    const prs = artifacts.filter(a => a.type === 'pull_request');
+    if (prs.length > 0)
+        parts.push(`Created ${prs.length} PR(s)`);
+    return parts.join('. ') || 'No changes detected';
+}
+export function isValidFilePath(path) {
+    const hasExtension = /\.[a-zA-Z0-9]+$/.test(path);
+    const isConfig = /^\.?[a-zA-Z]+rc|config|package\.json|tsconfig|\.gitignore/i.test(path);
+    const isValidChars = /^[a-zA-Z0-9_./-]+$/.test(path);
+    return isValidChars && (hasExtension || isConfig) && path.length < 200;
+}
+export function inferTaskType(output, files, title) {
+    const text = `${title || ''} ${output}`.toLowerCase();
+    const scores = {};
+    for (const [taskType, keywords] of Object.entries(TASK_TYPE_KEYWORDS)) {
+        scores[taskType] = 0;
+        for (const keyword of keywords) {
+            const regex = new RegExp(`\\b${keyword}\\b`, 'gi');
+            const matches = text.match(regex);
+            if (matches)
+                scores[taskType] += matches.length;
+        }
+    }
+    for (const file of files) {
+        if (/\.test\.|\.spec\.|__tests__/i.test(file.path))
+            scores.test = (scores.test || 0) + 2;
+        if (/\.md$|readme|docs?\//i.test(file.path))
+            scores.documentation = (scores.documentation || 0) + 2;
+        if (/\.gitignore|config|package\.json/i.test(file.path))
+            scores.chore = (scores.chore || 0) + 2;
+    }
+    let max = 0, type = 'feature';
+    for (const [t, s] of Object.entries(scores)) {
+        if (s > max) {
+            max = s;
+            type = t;
+        }
+    }
+    return max > 0 ? type : 'feature';
+}
+export function inferComponent(files) {
+    if (files.length === 0)
+        return undefined;
+    const counts = {};
+    for (const file of files) {
+        for (const { pattern, component } of COMPONENT_PATTERNS) {
+            if (pattern.test(file.path)) {
+                counts[component] = (counts[component] || 0) + 1;
+                break;
+            }
+        }
+    }
+    let max = 0, primary;
+    for (const [c, count] of Object.entries(counts)) {
+        if (count > max) {
+            max = count;
+            primary = c;
+        }
+    }
+    return primary;
+}
+export function generateSmartTitle(whatChanged, files, artifacts, taskType) {
+    const typePrefix = {
+        bug_fix: 'Fix',
+        feature: 'Add',
+        refactor: 'Refactor',
+        documentation: 'Document',
+        test: 'Test',
+        performance: 'Optimize',
+        security: 'Secure',
+        chore: 'Update',
+    };
+    const prefix = typePrefix[taskType] || 'Update';
+    if (files.length === 0 && artifacts.length > 0) {
+        const pr = artifacts.find(a => a.type === 'pull_request');
+        if (pr)
+            return `Create PR #${pr.identifier}`;
+    }
+    if (files.length > 0) {
+        const paths = files.map(f => f.path);
+        const commonDir = findCommonDir(paths);
+        if (commonDir && files.length > 1) {
+            const dirName = commonDir.split('/').pop() || commonDir;
+            return `${prefix} ${dirName} (${files.length} files)`;
+        }
+        const fileName = files[0].path.split('/').pop() || files[0].path;
+        const cleanName = fileName.replace(/\.[^/.]+$/, '');
+        return `${prefix} ${cleanName || fileName}`;
+    }
+    return prefix;
+}
+function findCommonDir(paths) {
+    if (paths.length <= 1)
+        return undefined;
+    const parts = paths[0].split('/');
+    if (parts.length <= 1)
+        return undefined;
+    let common = parts.slice(0, -1);
+    for (let i = 1; i < paths.length; i++) {
+        const current = paths[i].split('/').slice(0, -1);
+        let j = 0;
+        while (j < common.length && j < current.length && common[j] === current[j])
+            j++;
+        common = common.slice(0, j);
+    }
+    return common.length > 0 ? common.join('/') : undefined;
+}
+//# sourceMappingURL=extractor.js.map

package/dist/summaries/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Structured Summaries Module
+ *
+ * Provides functionality for extracting, storing, and querying
+ * structured summaries from AI agent task executions.
+ *
+ * Phase 7: Structured Summaries
+ */
+export { createSummary, getSummary, getTaskSummaries, getSessionSummaries, querySummaries, searchSummaries, getSummaryStats, getRecentSummaries, deleteSummary, clearAllSummaries, } from './storage.js';
+export { extractFromTaskResult, extractFromSession, extractFromRawOutput, } from './extractor.js';
+export type { Summary, CreateSummaryInput, SummaryQuery, SummaryStats, FileChange, Decision, Blocker, Artifact, TokenUsage, Cost, } from '../types/summary.js';
+export { SummarySchema, CreateSummaryInputSchema, SummaryQuerySchema, } from '../types/summary.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/summaries/index.js

@@ -0,0 +1,14 @@
+/**
+ * Structured Summaries Module
+ *
+ * Provides functionality for extracting, storing, and querying
+ * structured summaries from AI agent task executions.
+ *
+ * Phase 7: Structured Summaries
+ */
+// Storage operations
+export { createSummary, getSummary, getTaskSummaries, getSessionSummaries, querySummaries, searchSummaries, getSummaryStats, getRecentSummaries, deleteSummary, clearAllSummaries, } from './storage.js';
+// Extraction functions
+export { extractFromTaskResult, extractFromSession, extractFromRawOutput, } from './extractor.js';
+export { SummarySchema, CreateSummaryInputSchema, SummaryQuerySchema, } from '../types/summary.js';
+//# sourceMappingURL=index.js.map

package/dist/summaries/storage.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Summary Storage Wrapper
+ *
+ * Re-routes summary operations to the persistent storage module.
+ */
+import type { Summary, CreateSummaryInput, SummaryQuery, SummaryStats } from '../types/summary.js';
+/**
+ * Create a new summary
+ */
+export declare function createSummary(input: CreateSummaryInput): Promise<Summary>;
+/**
+ * Get a summary by ID
+ * @param includeRawOutput - If true, fetches raw output from blob storage (lazy load)
+ */
+export declare function getSummary(id: string, includeRawOutput?: boolean): Promise<Summary | null>;
+/**
+ * Get summaries for a task
+ */
+export declare function getTaskSummaries(taskId: string): Promise<Summary[]>;
+/**
+ * Get summaries for a session
+ */
+export declare function getSessionSummaries(sessionId: string): Promise<Summary[]>;
+/**
+ * Query summaries with filters
+ */
+export declare function querySummaries(query: Partial<SummaryQuery>): Promise<{
+    summaries: Summary[];
+    total: number;
+}>;
+/**
+ * Search summaries by text
+ */
+export declare function searchSummaries(searchText: string, limit?: number): Promise<Summary[]>;
+/**
+ * Get summary statistics
+ */
+export declare function getSummaryStats(): Promise<SummaryStats>;
+/**
+ * Get recent summaries
+ */
+export declare function getRecentSummaries(limit?: number): Promise<Summary[]>;
+/**
+ * Delete a summary
+ */
+export declare function deleteSummary(id: string): Promise<boolean>;
+/**
+ * Clear all summaries (for testing)
+ */
+export declare function clearAllSummaries(): Promise<void>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/summaries/storage.js

@@ -0,0 +1,101 @@
+/**
+ * Summary Storage Wrapper
+ *
+ * Re-routes summary operations to the persistent storage module.
+ */
+import { getStorage } from '../storage/index.js';
+import { getEmbeddingService } from '../ai/embedding-service.js';
+import { logger } from '../utils/logger.js';
+import { randomUUID } from 'crypto';
+/**
+ * Create a new summary
+ */
+export async function createSummary(input) {
+    const summary = await getStorage().createSummary(input);
+    // Trigger embedding generation in background
+    generateAndStoreSummaryEmbedding(summary).catch(err => {
+        logger.error(`[Storage] Failed to generate embedding for summary ${summary.id}:`, err);
+    });
+    return summary;
+}
+/**
+ * Background task to generate and store entity embedding
+ */
+async function generateAndStoreSummaryEmbedding(summary) {
+    const service = getEmbeddingService();
+    const storage = getStorage();
+    if (!storage.storeEmbedding)
+        return;
+    // Combine key fields for better semantic representation
+    const textToIndex = `
+    Title: ${summary.title}
+    Changes: ${summary.whatChanged}
+    Rationale: ${summary.whyChanged || ''}
+    Decisions: ${summary.decisions.map(d => d.description).join(', ')}
+    Type: ${summary.taskType || ''}
+    Component: ${summary.component || ''}
+  `.trim();
+    const embedding = await service.generateEmbedding(textToIndex);
+    await storage.storeEmbedding(randomUUID(), 'summary', summary.id, embedding, 'semantic-v1');
+    logger.debug(`[Storage] Stored embedding for summary ${summary.id}`);
+}
+/**
+ * Get a summary by ID
+ * @param includeRawOutput - If true, fetches raw output from blob storage (lazy load)
+ */
+export async function getSummary(id, includeRawOutput = false) {
+    return await getStorage().getSummary(id, includeRawOutput);
+}
+/**
+ * Get summaries for a task
+ */
+export async function getTaskSummaries(taskId) {
+    return await getStorage().getTaskSummaries(taskId);
+}
+/**
+ * Get summaries for a session
+ */
+export async function getSessionSummaries(sessionId) {
+    const result = await getStorage().querySummaries({ sessionId });
+    return result.summaries;
+}
+/**
+ * Query summaries with filters
+ */
+export async function querySummaries(query) {
+    return await getStorage().querySummaries(query);
+}
+/**
+ * Search summaries by text
+ */
+export async function searchSummaries(searchText, limit = 20) {
+    const result = await getStorage().querySummaries({ search: searchText, limit });
+    return result.summaries;
+}
+/**
+ * Get summary statistics
+ */
+export async function getSummaryStats() {
+    return await getStorage().getSummaryStats();
+}
+/**
+ * Get recent summaries
+ */
+export async function getRecentSummaries(limit = 50) {
+    const result = await getStorage().querySummaries({ limit });
+    return result.summaries;
+}
+/**
+ * Delete a summary
+ */
+export async function deleteSummary(id) {
+    return await getStorage().deleteSummary(id);
+}
+/**
+ * Clear all summaries (for testing)
+ */
+export async function clearAllSummaries() {
+    // Not implemented in production storage for safety
+    console.warn('[Storage] clearAllSummaries called but not implemented for persistent storage');
+}
+//# sourceMappingURL=storage.js.map

package/dist/summaries/templates.d.ts

@@ -0,0 +1,68 @@
+import { Summary } from '../types/summary.js';
+/**
+ * Summary Templates - Generate formatted output from task summaries
+ *
+ * Supports:
+ * - PR descriptions (GitHub, GitLab, Bitbucket)
+ * - Changelog entries (Keep a Changelog format)
+ * - Release notes
+ * - Commit messages (Conventional Commits)
+ */
+/**
+ * Task type templates with conventional commit prefixes and changelog categories
+ */
+export declare const TASK_TYPE_TEMPLATES: Record<string, {
+    title: string;
+    prPrefix: string;
+    changelogCategory: 'Added' | 'Changed' | 'Fixed' | 'Removed' | 'Security' | 'Deprecated';
+    emoji: string;
+}>;
+/**
+ * PR description format options
+ */
+export interface PRDescriptionOptions {
+    format?: 'github' | 'gitlab' | 'bitbucket' | 'simple';
+    includeFileChanges?: boolean;
+    includeDecisions?: boolean;
+    includeBlockers?: boolean;
+    includeTokenStats?: boolean;
+}
+/**
+ * Generate a GitHub-formatted Pull Request description from a summary
+ */
+export declare function generatePRDescription(summary: Summary, options?: PRDescriptionOptions): string;
+/**
+ * Changelog options
+ */
+export interface ChangelogOptions {
+    version?: string;
+    date?: string;
+    format?: 'keepachangelog' | 'simple' | 'grouped';
+    includeIssueLinks?: boolean;
+    issueLinkBase?: string;
+}
+/**
+ * Generate a release changelog from a collection of summaries
+ * Uses Keep a Changelog format by default
+ */
+export declare function generateChangelog(summaries: Summary[], options?: ChangelogOptions | string): string;
+/**
+ * Generate release notes from summaries
+ */
+export declare function generateReleaseNotes(summaries: Summary[], options?: {
+    version: string;
+    title?: string;
+    includeStats?: boolean;
+}): string;
+/**
+ * Get conventional commit prefix for a task type
+ */
+export declare function getConventionalCommitPrefix(taskType: string): string;
+/**
+ * Generate a conventional commit message from a summary
+ */
+export declare function generateCommitMessage(summary: Summary, options?: {
+    maxLength?: number;
+    includeBody?: boolean;
+}): string;
+//# sourceMappingURL=templates.d.ts.map