squish-memory 1.0.2 → 1.2.0

package/dist/core/hooks/agent-hooks.js

@@ -0,0 +1,521 @@
+/**
+ * Agent Hooks - Core Logic
+ *
+ * Universal hooks for auto-capturing agent activities.
+ * Works with Claude Code, OpenCode, Cursor, Windsurf.
+ *
+ * Hook events:
+ * - sessionStart: Inject relevant memories on session start
+ * - postToolUse: Record observations after tool execution
+ * - sessionEnd: Save snapshot and sync learnings
+ * - preCompact: Save state before context compaction
+ */
+import { randomUUID } from 'crypto';
+import { createLearning } from '../ingestion/learnings.js';
+import { getRecent, rememberMemory } from '../memory/memories.js';
+import { logger } from '../logger.js';
+import { shouldCaptureTool, categorizeTool } from './capture-filter.js';
+import { inferTags } from './auto-tagger.js';
+import { ensureProject, getProjectByPath } from '../projects.js';
+import { autoAssignMemory, initializeDefaultPlaces } from '../places/index.js';
+import { compressForContext } from '../compression.js';
+import { getAgentPreferences } from '../agent-preferences.js';
+import { classifySignalEvent, distillSignalEvent } from '../ingestion/signal-engine.js';
+import { compactSessionWorkingSet, recordSessionSignal } from '../session/working-set.js';
+import { getDbClient } from '../lib/db-client.js';
+import { eq } from 'drizzle-orm';
+import { serializeMetadata, deserializeMetadata } from '../memory/serialization.js';
+import { addMemoryToGraph } from '../graph/graph-builder.js';
+import { addSessionContextToHotCache } from '../hot-cache.js';
+import { extractBeliefsFromMemory } from '../beliefs/extractor.js';
+import { upsertBeliefsForMemory, getRecentFailures, getActiveConstraints, getActiveDecisions } from '../beliefs/store.js';
+/** Session ID for tracking across agents */
+let currentSessionId = null;
+/**
+ * Generate a new session ID (universal across agents)
+ */
+export function generateSessionId() {
+    currentSessionId = randomUUID();
+    return currentSessionId;
+}
+/**
+ * Get current session ID
+ */
+export function getCurrentSessionId() {
+    return currentSessionId;
+}
+/**
+ * Set session ID (for resume/continue)
+ */
+export function setSessionId(sessionId) {
+    currentSessionId = sessionId;
+}
+/**
+ * Session start hook - inject relevant context
+ */
+export async function handleSessionStart(params) {
+    const { projectPath, mode, agentType } = params;
+    // Ensure project exists
+    await ensureProject(projectPath);
+    // Generate or get session ID
+    if (!currentSessionId) {
+        currentSessionId = generateSessionId();
+    }
+    logger.info(`[Hooks] Session start: ${mode} (agent: ${agentType}, session: ${currentSessionId})`);
+    // Get recent memories based on mode
+    const limit = mode === 'compact' ? 3 : 5;
+    const memories = await getRecent(projectPath, limit);
+    const compactedWorkingSet = await compactSessionWorkingSet(currentSessionId, projectPath);
+    // Get spatial memory context (places) for context injection
+    let placesContext = '';
+    try {
+        const { initializeDefaultPlaces, getProjectPlaces } = await import('../places/index.js');
+        const { getProjectByPath } = await import('../projects.js');
+        const project = await getProjectByPath(projectPath);
+        if (project) {
+            await initializeDefaultPlaces(project.id);
+            const places = await getProjectPlaces(project.id);
+            if (places.length > 0) {
+                const populatedPlaces = places.filter(p => p.memoryCount > 0).slice(0, 3);
+                if (populatedPlaces.length > 0) {
+                    placesContext = '\n\nActive places: ' + populatedPlaces.map(p => `${p.name} (${p.memoryCount})`).join(', ');
+                }
+            }
+        }
+    }
+    catch (e) {
+        // Don't fail if places not available
+        logger.debug(`[Hooks] Places context not available: ${e}`);
+    }
+    // Format for injection with compression
+    const formatted = memories.map((m, i) => {
+        const compressed = compressForContext(m.content || '');
+        return `${i + 1}. [${m.type}] ${compressed}`;
+    }).join('\n');
+    const workingSetContext = compactedWorkingSet.summary ? `Session working set:\n${compactedWorkingSet.summary}\n\n` : '';
+    const allContent = workingSetContext + formatted + placesContext;
+    // Get agent preferences for context injection
+    let preferences = [];
+    try {
+        const project = await getProjectByPath(projectPath);
+        if (project) {
+            preferences = await getAgentPreferences(project.id);
+            // Get beliefs for state reconstruction on session boot
+            // This is the "state reconstruction" - active beliefs shape next actions
+            const [failures, constraints, decisions] = await Promise.all([
+                getRecentFailures(project.id, 5),
+                getActiveConstraints(project.id, 10),
+                getActiveDecisions(project.id, 10),
+            ]);
+            // Format beliefs into context
+            const beliefsSection = formatBeliefsForContext(failures, constraints, decisions);
+            // Add beliefs to injected context
+            if (beliefsSection) {
+                allContent = beliefsSection + '\n\n' + allContent;
+            }
+            logger.info(`[Hooks] Injected ${failures.length} failures, ${constraints.length} constraints, ${decisions.length} decisions`);
+            return {
+                memories: allContent ? allContent.split('\n') : [],
+                sessionId: currentSessionId,
+                count: memories.length,
+                preferences: preferences.length > 0 ? preferences : undefined,
+                beliefs: {
+                    failures: failures.map(f => f.statement),
+                    constraints: constraints.map(c => c.statement),
+                    decisions: decisions.map(d => d.statement),
+                },
+            };
+        }
+    }
+    catch (e) {
+        logger.debug(`[Hooks] Agent preferences not available: ${e}`);
+    }
+    logger.info(`[Hooks] Injected ${memories.length} memories for session start`);
+    return {
+        memories: allContent ? allContent.split('\n') : [],
+        sessionId: currentSessionId,
+        count: memories.length,
+        preferences: preferences.length > 0 ? preferences : undefined,
+    };
+}
+/**
+ * Format beliefs into context section for session boot
+ * This drives "state reconstruction" - agent sees active constraints/failures/decisions
+ */
+function formatBeliefsForContext(failures, constraints, decisions) {
+    const sections = [];
+    if (failures.length > 0) {
+        sections.push('AVOID:\n' + failures.map((f, i) => `  ${i + 1}. ${f.statement}${f.context ? ` (${f.context})` : ''}`).join('\n'));
+    }
+    if (constraints.length > 0) {
+        sections.push('CONSTRAINTS:\n' + constraints.map((c, i) => `  ${i + 1}. ${c.statement}${c.context ? ` (${c.context})` : ''}`).join('\n'));
+    }
+    if (decisions.length > 0) {
+        sections.push('DECISIONS:\n' + decisions.map((d, i) => `  ${i + 1}. ${d.statement}${d.context ? ` (${d.context})` : ''}`).join('\n'));
+    }
+    if (sections.length === 0)
+        return '';
+    return sections.join('\n\n');
+}
+/**
+ * Post-tool-use hook - record observations
+ */
+export async function handlePostToolUse(params) {
+    const { toolName, toolInput, toolResult, projectPath, agentType } = params;
+    // Ensure project exists
+    await ensureProject(projectPath);
+    // Ensure session ID exists
+    if (!currentSessionId) {
+        currentSessionId = generateSessionId();
+    }
+    // Check if we should capture this tool
+    if (!shouldCaptureTool(toolName)) {
+        await recordSessionSignal({
+            sessionId: currentSessionId,
+            projectPath,
+            classification: 'discard',
+            distilledContent: `Filtered tool: ${toolName}`,
+            toolName,
+            target: extractTarget(toolName, toolInput),
+        });
+        return { captured: false, reason: `Tool ${toolName} filtered out` };
+    }
+    // Extract relevant information
+    const category = categorizeTool(toolName);
+    const target = extractTarget(toolName, toolInput);
+    const content = extractContent(toolName, toolInput, toolResult);
+    const signalDecision = classifySignalEvent({
+        toolName,
+        toolInput,
+        toolResult,
+        sessionId: currentSessionId,
+    });
+    const distilledContent = distillSignalEvent({
+        toolName,
+        command: String(toolInput.command || toolInput.cmd || ''),
+        content: signalDecision.content || content,
+        classification: signalDecision.classification,
+    });
+    // Infer tags from context
+    const tags = inferTags(toolName, toolInput, distilledContent || content);
+    await recordSessionSignal({
+        sessionId: currentSessionId,
+        projectPath,
+        classification: signalDecision.classification,
+        distilledContent,
+        toolName,
+        target,
+        metadata: {
+            activeFiles: extractActiveFiles(toolName, toolInput),
+            command: String(toolInput.command || toolInput.cmd || ''),
+            outcome: inferOutcome(signalDecision, toolResult),
+            contentHash: signalDecision.contentHash,
+            tokensSaved: signalDecision.estimatedSavings,
+            activePlaces: signalDecision.placeHint.placeType ? [signalDecision.placeHint.placeType] : [],
+            graphEntities: signalDecision.graphHint.entityTerms,
+            placeRouted: Boolean(signalDecision.placeHint.placeType),
+            graphEnriched: signalDecision.graphHint.shouldEnrich,
+        },
+    });
+    if (signalDecision.classification === 'discard') {
+        return { captured: false, reason: signalDecision.reasons.join(', ') };
+    }
+    if (signalDecision.classification === 'session-only') {
+        return { captured: false, reason: 'Stored in session working set only' };
+    }
+    try {
+        const memory = await rememberMemory({
+            content: `[${category}] ${distilledContent || content}`,
+            project: projectPath,
+            type: category === 'modification' ? 'decision' : category === 'planning' ? 'context' : 'observation',
+            source: 'auto-capture',
+            metadata: {
+                signal: {
+                    classification: signalDecision.classification,
+                    reasons: signalDecision.reasons,
+                    nuanceSuppressed: signalDecision.classification === 'durable-raw+distilled',
+                    wakeUpPriority: signalDecision.wakeUpPriority,
+                },
+                placeHint: signalDecision.placeHint,
+                graphHint: signalDecision.graphHint,
+                target,
+                toolName,
+            },
+        });
+        logger.info(`[Hooks] Captured ${toolName} → ${memory.id} (session: ${currentSessionId})`);
+        let placeAssignment;
+        try {
+            const project = await getProjectByPath(projectPath);
+            if (project) {
+                await initializeDefaultPlaces(project.id);
+                placeAssignment = await autoAssignMemory({
+                    memoryId: memory.id,
+                    projectId: project.id,
+                    toolName,
+                    content: memory.content,
+                    tags,
+                    memoryType: memory.type,
+                });
+            }
+        }
+        catch (placeError) {
+            logger.warn(`[Hooks] Place assignment failed: ${placeError}`);
+        }
+        let graphStatus = {
+            enriched: false,
+            entitiesCreated: 0,
+            relationsCreated: 0,
+            source: 'none',
+            entityTerms: signalDecision.graphHint.entityTerms,
+        };
+        if (signalDecision.graphHint.shouldEnrich) {
+            try {
+                const graphResult = await addMemoryToGraph(memory.id, { preferLLM: true });
+                graphStatus = {
+                    enriched: graphResult.entitiesCreated > 0 || graphResult.relationsCreated > 0,
+                    entitiesCreated: graphResult.entitiesCreated,
+                    relationsCreated: graphResult.relationsCreated,
+                    source: graphResult.source,
+                    entityTerms: signalDecision.graphHint.entityTerms,
+                };
+            }
+            catch (graphError) {
+                logger.warn(`[Hooks] Graph enrichment failed: ${graphError}`);
+            }
+        }
+        let rawFallbackSnapshotId;
+        if (signalDecision.classification === 'durable-raw+distilled') {
+            rawFallbackSnapshotId = await attachRawFallbackSnapshot(memory.id, signalDecision.content, signalDecision.reasons);
+        }
+        await attachInspectionMetadata(memory.id, {
+            classification: signalDecision.classification,
+            reasons: signalDecision.reasons,
+            rawFallbackSnapshotId,
+            nuanceSuppressed: signalDecision.classification === 'durable-raw+distilled',
+            placeId: placeAssignment?.placeId,
+            placeType: placeAssignment?.placeType,
+            graph: graphStatus,
+        });
+        try {
+            const project = await getProjectByPath(projectPath);
+            if (project) {
+                const beliefs = extractBeliefsFromMemory({
+                    memoryId: memory.id,
+                    content: memory.content,
+                    type: memory.type,
+                    metadata: memory.metadata ?? null,
+                });
+                if (beliefs.length > 0) {
+                    const storedBeliefs = await upsertBeliefsForMemory({
+                        projectId: project.id,
+                        memoryId: memory.id,
+                        beliefs,
+                    });
+                    await attachBeliefInspectionMetadata(memory.id, storedBeliefs);
+                }
+            }
+        }
+        catch (beliefError) {
+            logger.warn(`[Hooks] Belief extraction failed: ${beliefError}`);
+        }
+        return {
+            captured: true,
+            memoryId: memory.id,
+        };
+    }
+    catch (error) {
+        logger.error(`[Hooks] Failed to capture:`, error);
+        return { captured: false, reason: 'Failed to create learning' };
+    }
+}
+async function attachRawFallbackSnapshot(memoryId, rawContent, reasons) {
+    const { db, schema } = await getDbClient();
+    const snapshotId = randomUUID();
+    await db.insert(schema.memorySnapshots).values({
+        id: snapshotId,
+        memoryId,
+        snapshotType: 'periodic',
+        content: rawContent,
+        metadata: serializeMetadata({
+            role: 'raw-fallback',
+            reasons,
+            createdBy: 'signal-engine',
+        }),
+        createdAt: new Date(),
+    });
+    return snapshotId;
+}
+async function attachInspectionMetadata(memoryId, signal) {
+    const { db, schema } = await getDbClient();
+    const rows = await db.select().from(schema.memories).where(eq(schema.memories.id, memoryId)).limit(1);
+    const row = rows[0];
+    if (!row)
+        return;
+    const details = deserializeMetadata(row.metadata ?? null) ?? {};
+    const next = {
+        ...details,
+        signal,
+        classification: signal.classification,
+        reasons: signal.reasons,
+        rawFallbackSnapshotId: signal.rawFallbackSnapshotId,
+        nuanceSuppressed: signal.nuanceSuppressed,
+        placeId: signal.placeId,
+        placeType: signal.placeType,
+        graph: signal.graph,
+        graphStatus: signal.graph
+            ? `${signal.graph.enriched ? 'enriched' : 'skipped'} (${signal.graph.entitiesCreated} entities, ${signal.graph.relationsCreated} relations)`
+            : 'none',
+    };
+    await db.update(schema.memories)
+        .set({ metadata: serializeMetadata(next), updatedAt: new Date() })
+        .where(eq(schema.memories.id, memoryId));
+}
+async function attachBeliefInspectionMetadata(memoryId, beliefs) {
+    const { db, schema } = await getDbClient();
+    const rows = await db.select().from(schema.memories).where(eq(schema.memories.id, memoryId)).limit(1);
+    const row = rows[0];
+    if (!row)
+        return;
+    const details = deserializeMetadata(row.metadata ?? null) ?? {};
+    const next = {
+        ...details,
+        beliefs: beliefs.map((belief) => ({
+            id: belief.id,
+            type: belief.type,
+            statement: belief.statement,
+            status: belief.status,
+            confidence: belief.confidence,
+            sourceMemoryIds: belief.sourceMemoryIds,
+            reason: belief.reason,
+        })),
+    };
+    await db.update(schema.memories)
+        .set({ metadata: serializeMetadata(next), updatedAt: new Date() })
+        .where(eq(schema.memories.id, memoryId));
+}
+function extractActiveFiles(toolName, toolInput) {
+    const path = String(toolInput.filePath || toolInput.path || '');
+    if (['Write', 'Edit', 'MultiEdit'].includes(toolName) && path) {
+        return [path];
+    }
+    return [];
+}
+function inferOutcome(signalDecision, toolResult) {
+    const content = typeof toolResult === 'string' ? toolResult.toLowerCase() : String(toolResult ?? '').toLowerCase();
+    if (signalDecision.classification === 'discard')
+        return 'suppressed';
+    if (/\bfail|error|exception|traceback\b/.test(content))
+        return 'failure';
+    if (/\bpass|success|completed\b/.test(content))
+        return 'success';
+    return undefined;
+}
+/**
+ * Session end hook - save snapshot and sync to persistent hot cache
+ */
+export async function handleSessionEnd(params) {
+    const { projectPath, agentType, workInProgress } = params;
+    // Ensure project exists
+    await ensureProject(projectPath);
+    logger.info(`[Hooks] Session end (agent: ${agentType}, session: ${currentSessionId})`);
+    // Save session snapshot as a learning
+    if (workInProgress) {
+        const snapshot = await createLearning({
+            type: 'insight',
+            content: `[SESSION SNAPSHOT] ${workInProgress}`,
+            action: 'session-end',
+            project: projectPath,
+            autoLink: false,
+        });
+        logger.info(`[Hooks] Saved session snapshot: ${snapshot.id}`);
+        // NEW: Also save to persistent hot cache (survives restart)
+        try {
+            const workingSet = await compactSessionWorkingSet(projectPath);
+            await addSessionContextToHotCache({
+                activeFiles: workingSet?.activeFiles || [],
+                commands: workingSet?.recentCommands?.slice(-3).map(c => c.command) || [],
+                failures: workingSet?.recentFailures?.slice(-2) || [],
+                decisions: [], // Could extract from recent signals
+                hypotheses: workingSet?.currentHypotheses?.slice(-2) || [],
+            }, projectPath);
+            logger.info('[Hooks] Saved session context to hot cache');
+        }
+        catch (error) {
+            logger.warn('[Hooks] Failed to save hot cache', error);
+        }
+        currentSessionId = null; // Clear session
+        return {
+            snapshotId: snapshot.id,
+            memoriesSaved: 1,
+        };
+    }
+    currentSessionId = null;
+    return {
+        memoriesSaved: 0,
+    };
+}
+/**
+ * Pre-compact hook - save state for recovery
+ */
+export async function handlePreCompact(params) {
+    const { projectPath, agentType } = params;
+    // Ensure project exists
+    await ensureProject(projectPath);
+    logger.info(`[Hooks] Pre-compact (agent: ${agentType})`);
+    // Get recent work for recovery
+    const recent = await getRecent(projectPath, 3);
+    // Save state
+    const state = await createLearning({
+        type: 'insight',
+        content: `[PRE-COMPACT] State saved for recovery. Recent: ${recent.map(r => r.content?.substring(0, 50)).join(' | ')}`,
+        action: 'pre-compact',
+        project: projectPath,
+        autoLink: false,
+    });
+    return {
+        stateSaved: true,
+        stateId: state.id,
+    };
+}
+/**
+ * Extract target from tool input
+ */
+function extractTarget(toolName, toolInput) {
+    switch (toolName) {
+        case 'Write':
+        case 'Edit':
+            return String(toolInput.filePath || toolInput.path || 'unknown');
+        case 'Bash':
+            return String(toolInput.command || toolInput.cmd || 'unknown');
+        case 'Task':
+            return String(toolInput.description || toolInput.name || 'unknown');
+        default:
+            return 'unknown';
+    }
+}
+/**
+ * Extract content summary from tool result
+ */
+function extractContent(toolName, toolInput, toolResult) {
+    switch (toolName) {
+        case 'Write':
+            return `Wrote: ${toolInput.filePath || toolInput.path}`;
+        case 'Edit':
+            return `Edited: ${toolInput.filePath || toolInput.path}`;
+        case 'Bash':
+            const cmd = String(toolInput.command || toolInput.cmd || '');
+            if (cmd.includes('commit'))
+                return `Git commit executed`;
+            if (cmd.includes('test'))
+                return `Tests run`;
+            return `Command: ${cmd.substring(0, 50)}`;
+        case 'Task':
+            return `Task: ${toolInput.description || toolInput.name || 'unknown'}`;
+        default:
+            return `Used: ${toolName}`;
+    }
+}
+// Re-export for convenience
+export { shouldCaptureTool, categorizeTool } from './capture-filter.js';
+export { inferTags } from './auto-tagger.js';
+//# sourceMappingURL=agent-hooks.js.map

package/dist/core/hooks/auto-tagger.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Auto-Tagger - Infer tags from context
+ *
+ * Analyzes tool input/output to automatically infer relevant tags.
+ * Uses pattern matching to classify actions.
+ */
+/**
+ * Infer tags based on tool, input, and content
+ */
+export declare function inferTags(toolName: string, toolInput: Record<string, unknown>, content: string): string[];
+/**
+ * Extract tags from commit message
+ */
+export declare function extractCommitTags(commitMessage: string): string[];
+/**
+ * Extract tags from file path
+ */
+export declare function extractFileTags(filePath: string): string[];
+//# sourceMappingURL=auto-tagger.d.ts.map

package/dist/core/hooks/auto-tagger.js

@@ -0,0 +1,155 @@
+/**
+ * Auto-Tagger - Infer tags from context
+ *
+ * Analyzes tool input/output to automatically infer relevant tags.
+ * Uses pattern matching to classify actions.
+ */
+/**
+ * Infer tags based on tool, input, and content
+ */
+export function inferTags(toolName, toolInput, content) {
+    const tags = ['hook', 'autocapture']; // Always add these
+    const tool = toolName.toLowerCase();
+    const inputStr = JSON.stringify(toolInput).toLowerCase();
+    const contentLower = content.toLowerCase();
+    // File type tags
+    if (tool === 'write' || tool === 'edit') {
+        const filePath = String(toolInput.filePath || toolInput.path || '');
+        if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
+            tags.push('typescript');
+        }
+        else if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
+            tags.push('javascript');
+        }
+        else if (filePath.endsWith('.json')) {
+            tags.push('config');
+        }
+        else if (filePath.endsWith('.md')) {
+            tags.push('documentation');
+        }
+        else if (filePath.endsWith('.test.ts') || filePath.endsWith('.spec.ts')) {
+            tags.push('test');
+        }
+        // Feature/fix detection
+        if (contentLower.includes('fix') || contentLower.includes('bug')) {
+            tags.push('bugfix');
+        }
+        else if (contentLower.includes('refactor')) {
+            tags.push('refactor');
+        }
+        else if (contentLower.includes('feature') || contentLower.includes('add')) {
+            tags.push('feature');
+        }
+        else if (contentLower.includes('test')) {
+            tags.push('testing');
+        }
+    }
+    // Bash command tags
+    if (tool === 'bash') {
+        const cmd = String(toolInput.command || toolInput.cmd || '');
+        if (cmd.includes('git commit')) {
+            tags.push('commit', 'version-control');
+        }
+        else if (cmd.includes('test') || cmd.includes('jest') || cmd.includes('vitest')) {
+            tags.push('testing', 'test');
+        }
+        else if (cmd.includes('build') || cmd.includes('compile')) {
+            tags.push('build');
+        }
+        else if (cmd.includes('install')) {
+            tags.push('dependencies');
+        }
+        else if (cmd.includes('lint') || cmd.includes('format')) {
+            tags.push('linting');
+        }
+    }
+    // Task tags
+    if (tool === 'task' || tool === 'todowrite') {
+        tags.push('task', 'planning');
+        if (contentLower.includes('fix') || contentLower.includes('bug')) {
+            tags.push('bugfix');
+        }
+        else if (contentLower.includes('feature')) {
+            tags.push('feature');
+        }
+        else if (contentLower.includes('refactor')) {
+            tags.push('refactor');
+        }
+    }
+    // Deduplicate
+    return [...new Set(tags)];
+}
+/**
+ * Extract tags from commit message
+ */
+export function extractCommitTags(commitMessage) {
+    const tags = ['commit'];
+    const msg = commitMessage.toLowerCase();
+    // Conventional commits
+    if (msg.startsWith('feat:') || msg.includes('feature')) {
+        tags.push('feature', 'conventional-commit');
+    }
+    else if (msg.startsWith('fix:') || msg.includes('bugfix')) {
+        tags.push('bugfix', 'conventional-commit');
+    }
+    else if (msg.startsWith('refactor:')) {
+        tags.push('refactor', 'conventional-commit');
+    }
+    else if (msg.startsWith('docs:')) {
+        tags.push('documentation', 'conventional-commit');
+    }
+    else if (msg.startsWith('test:')) {
+        tags.push('testing', 'conventional-commit');
+    }
+    else if (msg.startsWith('chore:')) {
+        tags.push('chore', 'conventional-commit');
+    }
+    return tags;
+}
+/**
+ * Extract tags from file path
+ */
+export function extractFileTags(filePath) {
+    const tags = [];
+    const path = filePath.toLowerCase();
+    // By extension
+    if (path.endsWith('.ts') || path.endsWith('.tsx')) {
+        tags.push('typescript');
+    }
+    else if (path.endsWith('.js') || path.endsWith('.jsx')) {
+        tags.push('javascript');
+    }
+    else if (path.endsWith('.py')) {
+        tags.push('python');
+    }
+    else if (path.endsWith('.go')) {
+        tags.push('golang');
+    }
+    else if (path.endsWith('.rs')) {
+        tags.push('rust');
+    }
+    else if (path.endsWith('.java')) {
+        tags.push('java');
+    }
+    else if (path.endsWith('.json')) {
+        tags.push('config');
+    }
+    else if (path.endsWith('.md')) {
+        tags.push('documentation');
+    }
+    // By directory pattern
+    if (path.includes('/test') || path.includes('/tests') || path.includes('__tests__')) {
+        tags.push('test');
+    }
+    else if (path.includes('/src/')) {
+        tags.push('source');
+    }
+    else if (path.includes('/lib/') || path.includes('/utils/')) {
+        tags.push('library');
+    }
+    else if (path.includes('/config/') || path.includes('/scripts/')) {
+        tags.push('config');
+    }
+    return tags;
+}
+//# sourceMappingURL=auto-tagger.js.map