squish-memory 1.1.5 → 1.2.1

package/dist/core/places/places.js

@@ -1,314 +0,0 @@
-/**
- * Places Module - Spatial memory organization (Method of Loci)
- *
- * Provides spatial "places" for memory organization:
- * - Entry Hall: Project overview, goals
- * - Library: Research, patterns, discoveries
- * - Workshop: Implementation, code, fixes
- * - Lab: Experiments, tests, trials
- * - Office: Decisions, planning, roadmap
- * - Garden: Ideas, future concepts
- * - Archive: Completed, historical
- */
-import { randomUUID } from 'crypto';
-import { eq, and, isNull } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-// Default places configuration
-export const DEFAULT_PLACES = [
-    { name: 'Entry Hall', placeType: 'entry_hall', lociIndex: 0, description: 'Project overview, goals, and current status', purpose: 'Quick orientation to project state' },
-    { name: 'Library', placeType: 'library', lociIndex: 1, description: 'Research, patterns, and discoveries', purpose: 'Reference knowledge and learned patterns' },
-    { name: 'Workshop', placeType: 'workshop', lociIndex: 2, description: 'Implementation, code, and fixes', purpose: 'Active development and recent changes' },
-    { name: 'Lab', placeType: 'lab', lociIndex: 3, description: 'Experiments, tests, and trials', purpose: 'Testing and exploration results' },
-    { name: 'Office', placeType: 'office', lociIndex: 4, description: 'Decisions, planning, and roadmap', purpose: 'Project direction and decisions' },
-    { name: 'Garden', placeType: 'garden', lociIndex: 5, description: 'Ideas and future concepts', purpose: 'Brainstorming and upcoming plans' },
-    { name: 'Archive', placeType: 'archive', lociIndex: 6, description: 'Completed and historical items', purpose: 'Reference for completed work' },
-];
-/**
- * Create a new place
- */
-export async function createPlace(input) {
-    const db = await getDb();
-    if (!db) {
-        throw new Error('Database unavailable');
-    }
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const id = randomUUID();
-    // Check for duplicate
-    const existing = await sqliteDb.select()
-        .from(schema.places)
-        .where(and(eq(schema.places.projectId, input.projectId), eq(schema.places.name, input.name), input.parentId
-        ? eq(schema.places.parentId, input.parentId)
-        : isNull(schema.places.parentId)))
-        .limit(1);
-    if (existing.length > 0) {
-        throw new Error(`Place "${input.name}" already exists`);
-    }
-    await sqliteDb.insert(schema.places).values({
-        id,
-        projectId: input.projectId,
-        name: input.name,
-        placeType: input.placeType,
-        parentId: input.parentId || null,
-        lociIndex: input.lociIndex ?? 0,
-        positionX: 0,
-        positionY: 0,
-        description: input.description || null,
-        purpose: input.purpose || null,
-        memoryCount: 0,
-    });
-    logger.info(`[Places] Created place: ${input.name} (${input.placeType})`);
-    return {
-        id,
-        projectId: input.projectId,
-        name: input.name,
-        placeType: input.placeType,
-        parentId: input.parentId || null,
-        lociIndex: input.lociIndex ?? 0,
-        positionX: 0,
-        positionY: 0,
-        description: input.description || null,
-        purpose: input.purpose || null,
-        memoryCount: 0,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    };
-}
-/**
- * Get a place by ID
- */
-export async function getPlace(id) {
-    const db = await getDb();
-    if (!db)
-        return null;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const result = await sqliteDb.select()
-        .from(schema.places)
-        .where(eq(schema.places.id, id))
-        .limit(1);
-    if (result.length === 0)
-        return null;
-    const row = result[0];
-    return {
-        id: row.id,
-        projectId: row.project_id,
-        name: row.name,
-        placeType: (row.place_type || row.placeType || 'custom'),
-        parentId: row.parent_id || row.parentId || null,
-        lociIndex: row.loci_index ?? row.lociIndex ?? 0,
-        positionX: row.position_x ?? row.positionX ?? 0,
-        positionY: row.position_y ?? row.positionY ?? 0,
-        description: row.description,
-        purpose: row.purpose,
-        memoryCount: row.memory_count ?? row.memoryCount ?? 0,
-        createdAt: new Date(row.created_at || row.createdAt || Date.now()),
-        updatedAt: new Date(row.updated_at || row.updatedAt || Date.now()),
-    };
-}
-/**
- * Get places for a project, ordered by loci_index
- */
-export async function getProjectPlaces(projectId) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const results = await sqliteDb.select()
-        .from(schema.places)
-        .where(eq(schema.places.projectId, projectId))
-        .orderBy(schema.places.lociIndex);
-    return results.map((row) => ({
-        id: row.id,
-        projectId: row.project_id,
-        name: row.name,
-        placeType: (row.place_type || row.placeType),
-        parentId: row.parent_id || row.parentId,
-        lociIndex: row.loci_index ?? row.lociIndex ?? 0,
-        positionX: row.position_x ?? row.positionX ?? 0,
-        positionY: row.position_y ?? row.positionY ?? 0,
-        description: row.description,
-        purpose: row.purpose,
-        memoryCount: row.memory_count ?? row.memoryCount ?? 0,
-        createdAt: new Date(row.created_at || row.createdAt),
-        updatedAt: new Date(row.updated_at || row.updatedAt),
-    }));
-}
-/**
- * Get place by type for a project
- */
-export async function getPlaceByType(projectId, placeType) {
-    const db = await getDb();
-    if (!db)
-        return null;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const result = await sqliteDb.select()
-        .from(schema.places)
-        .where(and(eq(schema.places.projectId, projectId), eq(schema.places.placeType, placeType)))
-        .limit(1);
-    if (result.length === 0)
-        return null;
-    const row = result[0];
-    return {
-        id: row.id,
-        projectId: row.project_id,
-        name: row.name,
-        placeType: (row.place_type || row.placeType || 'custom'),
-        parentId: row.parent_id || row.parentId || null,
-        lociIndex: row.loci_index ?? row.lociIndex ?? 0,
-        positionX: row.position_x ?? row.positionX ?? 0,
-        positionY: row.position_y ?? row.positionY ?? 0,
-        description: row.description,
-        purpose: row.purpose,
-        memoryCount: row.memory_count ?? row.memoryCount ?? 0,
-        createdAt: new Date(row.created_at || row.createdAt || Date.now()),
-        updatedAt: new Date(row.updated_at || row.updatedAt || Date.now()),
-    };
-}
-/**
- * Update a place
- */
-export async function updatePlace(id, input) {
-    const db = await getDb();
-    if (!db)
-        return null;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const updateData = {};
-    if (input.name !== undefined)
-        updateData.name = input.name;
-    if (input.description !== undefined)
-        updateData.description = input.description;
-    if (input.purpose !== undefined)
-        updateData.purpose = input.purpose;
-    if (input.lociIndex !== undefined)
-        updateData.lociIndex = input.lociIndex;
-    if (input.positionX !== undefined)
-        updateData.positionX = input.positionX;
-    if (input.positionY !== undefined)
-        updateData.positionY = input.positionY;
-    if (Object.keys(updateData).length === 0) {
-        return getPlace(id);
-    }
-    await sqliteDb.update(schema.places)
-        .set(updateData)
-        .where(eq(schema.places.id, id));
-    return getPlace(id);
-}
-/**
- * Delete a place
- */
-export async function deletePlace(id) {
-    const db = await getDb();
-    if (!db)
-        return false;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    await sqliteDb.delete(schema.places).where(eq(schema.places.id, id));
-    logger.info(`[Places] Deleted place: ${id}`);
-    return true;
-}
-/**
- * Initialize default 7 places for a project
- */
-export async function initializeDefaultPlaces(projectId) {
-    const created = [];
-    for (const placeConfig of DEFAULT_PLACES) {
-        // Check if place of this type already exists
-        const existing = await getPlaceByType(projectId, placeConfig.placeType);
-        if (existing) {
-            created.push(existing);
-            continue;
-        }
-        const place = await createPlace({
-            projectId,
-            name: placeConfig.name,
-            placeType: placeConfig.placeType,
-            parentId: null,
-            lociIndex: placeConfig.lociIndex,
-            description: placeConfig.description,
-            purpose: placeConfig.purpose,
-        });
-        created.push(place);
-    }
-    // Also initialize default rules if none exist
-    const { initializeDefaultRules } = await import('./rules.js');
-    await initializeDefaultRules(projectId);
-    logger.info(`[Places] Initialized ${created.length} default places for project: ${projectId}`);
-    return created;
-}
-/**
- * Get place by loci index
- */
-export async function getPlaceByLociIndex(projectId, lociIndex) {
-    const db = await getDb();
-    if (!db)
-        return null;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const result = await sqliteDb.select()
-        .from(schema.places)
-        .where(and(eq(schema.places.projectId, projectId), eq(schema.places.lociIndex, lociIndex)))
-        .limit(1);
-    if (result.length === 0)
-        return null;
-    const row = result[0];
-    return {
-        id: row.id,
-        projectId: row.project_id,
-        name: row.name,
-        placeType: (row.place_type || row.placeType || 'custom'),
-        parentId: row.parent_id || row.parentId || null,
-        lociIndex: row.loci_index ?? row.lociIndex ?? 0,
-        positionX: row.position_x ?? row.positionX ?? 0,
-        positionY: row.position_y ?? row.positionY ?? 0,
-        description: row.description,
-        purpose: row.purpose,
-        memoryCount: row.memory_count ?? row.memoryCount ?? 0,
-        createdAt: new Date(row.created_at || row.createdAt || Date.now()),
-        updatedAt: new Date(row.updated_at || row.updatedAt || Date.now()),
-    };
-}
-/**
- * Update memory count for a place
- */
-export async function updatePlaceMemoryCount(placeId) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    // Count memories in this place
-    const countResult = await sqliteDb.select({ count: schema.memoryPlaces.id })
-        .from(schema.memoryPlaces)
-        .where(eq(schema.memoryPlaces.placeId, placeId));
-    const count = countResult.length;
-    await sqliteDb.update(schema.places)
-        .set({ memoryCount: count })
-        .where(eq(schema.places.id, placeId));
-}
-/**
- * Sync all place memory counts - recalculate counts for all places in a project
- * Useful for fixing counts after bulk operations or data recovery
- */
-export async function syncAllPlaceMemoryCounts(projectId) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    // Get all places for this project
-    const allPlaces = await sqliteDb.select()
-        .from(schema.places)
-        .where(eq(schema.places.projectId, projectId));
-    // Update each place's memory count
-    for (const place of allPlaces) {
-        await updatePlaceMemoryCount(place.id);
-    }
-    logger.info(`[Places] Synced memory counts for ${allPlaces.length} places`);
-}
-//# sourceMappingURL=places.js.map

package/dist/core/places/rules.d.ts

@@ -1,74 +0,0 @@
-/**
- * Places Rules Engine - Auto-assignment logic
- *
- * Evaluates which place a memory should be assigned to based on:
- * - Tool used (Write, Edit, Task, etc.)
- * - Content keywords
- * - Tags
- * - Memory type
- */
-import type { PlaceType } from './places.js';
-export interface PlaceRule {
-    id: string;
-    projectId: string;
-    name: string;
-    placeType: PlaceType;
-    matchTool: string | null;
-    matchKeyword: string | null;
-    matchTag: string | null;
-    matchMemoryType: string | null;
-    priority: number;
-    enabled: boolean;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface PlaceRuleCreateInput {
-    projectId: string;
-    name: string;
-    placeType: PlaceType;
-    matchTool?: string;
-    matchKeyword?: string;
-    matchTag?: string;
-    matchMemoryType?: string;
-    priority?: number;
-    enabled?: boolean;
-}
-export interface RuleMatchInput {
-    toolName?: string;
-    content?: string;
-    tags?: string[];
-    memoryType?: string;
-}
-/**
- * Default auto-assignment rules
- */
-export declare const DEFAULT_RULES: Omit<PlaceRuleCreateInput, 'projectId'>[];
-/**
- * Create a place rule
- */
-export declare function createPlaceRule(input: PlaceRuleCreateInput): Promise<PlaceRule>;
-/**
- * Get rules for a project
- */
-export declare function getProjectRules(projectId: string): Promise<PlaceRule[]>;
-/**
- * Check if a rule matches the input
- */
-export declare function matchesRule(rule: PlaceRule, input: RuleMatchInput): boolean;
-/**
- * Find matching place for a memory based on rules
- */
-export declare function findMatchingPlace(projectId: string, input: RuleMatchInput): Promise<PlaceType | null>;
-/**
- * Initialize default rules for a project
- */
-export declare function initializeDefaultRules(projectId: string): Promise<PlaceRule[]>;
-/**
- * Delete a rule
- */
-export declare function deletePlaceRule(id: string): Promise<boolean>;
-/**
- * Update a rule
- */
-export declare function updatePlaceRule(id: string, updates: Partial<PlaceRuleCreateInput>): Promise<PlaceRule | null>;
-//# sourceMappingURL=rules.d.ts.map

package/dist/core/places/rules.js

@@ -1,240 +0,0 @@
-/**
- * Places Rules Engine - Auto-assignment logic
- *
- * Evaluates which place a memory should be assigned to based on:
- * - Tool used (Write, Edit, Task, etc.)
- * - Content keywords
- * - Tags
- * - Memory type
- */
-import { randomUUID } from 'crypto';
-import { eq, desc } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-/**
- * Default auto-assignment rules
- */
-export const DEFAULT_RULES = [
-    // Workshop - Implementation, code, fixes
-    { name: 'Write to Workshop', placeType: 'workshop', matchTool: 'Write', priority: 100 },
-    { name: 'Edit to Workshop', placeType: 'workshop', matchTool: 'Edit', priority: 100 },
-    { name: 'MultiEdit to Workshop', placeType: 'workshop', matchTool: 'MultiEdit', priority: 100 },
-    { name: 'Fix keyword to Workshop', placeType: 'workshop', matchKeyword: 'fix', priority: 80 },
-    { name: 'Bug keyword to Workshop', placeType: 'workshop', matchKeyword: 'bug', priority: 80 },
-    // Lab - Experiments, tests
-    { name: 'Test to Lab', placeType: 'lab', matchTool: 'Bash', matchKeyword: 'test', priority: 90 },
-    { name: 'Test tag to Lab', placeType: 'lab', matchTag: 'test', priority: 85 },
-    // Office - Decisions, planning
-    { name: 'Task to Office', placeType: 'office', matchTool: 'Task', priority: 100 },
-    { name: 'TodoWrite to Office', placeType: 'office', matchTool: 'TodoWrite', priority: 100 },
-    { name: 'Decision keyword to Office', placeType: 'office', matchKeyword: 'decided', priority: 70 },
-    { name: 'Planning keyword to Office', placeType: 'office', matchKeyword: 'will implement', priority: 70 },
-    // Library - Research, patterns
-    { name: 'Search to Library', placeType: 'library', matchTool: 'grep', priority: 90 },
-    { name: 'WebFetch to Library', placeType: 'library', matchTool: 'WebFetch', priority: 85 },
-    { name: 'Research keyword to Library', placeType: 'library', matchKeyword: 'research', priority: 80 },
-    { name: 'Pattern keyword to Library', placeType: 'library', matchKeyword: 'pattern', priority: 75 },
-    // Garden - Ideas, future
-    { name: 'Idea keyword to Garden', placeType: 'garden', matchKeyword: 'idea', priority: 80 },
-    { name: 'Explore keyword to Garden', placeType: 'garden', matchKeyword: 'explore', priority: 75 },
-    { name: 'Future keyword to Garden', placeType: 'garden', matchKeyword: 'will add', priority: 70 },
-];
-/**
- * Create a place rule
- */
-export async function createPlaceRule(input) {
-    const db = await getDb();
-    if (!db) {
-        throw new Error('Database unavailable');
-    }
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const id = randomUUID();
-    await sqliteDb.insert(schema.placeRules).values({
-        id,
-        projectId: input.projectId,
-        name: input.name,
-        placeType: input.placeType,
-        matchTool: input.matchTool || null,
-        matchKeyword: input.matchKeyword || null,
-        matchTag: input.matchTag || null,
-        matchMemoryType: input.matchMemoryType || null,
-        priority: input.priority ?? 0,
-        enabled: input.enabled !== false ? 1 : 0,
-    });
-    logger.info(`[PlaceRules] Created rule: ${input.name} -> ${input.placeType}`);
-    return {
-        id,
-        projectId: input.projectId,
-        name: input.name,
-        placeType: input.placeType,
-        matchTool: input.matchTool || null,
-        matchKeyword: input.matchKeyword || null,
-        matchTag: input.matchTag || null,
-        matchMemoryType: input.matchMemoryType || null,
-        priority: input.priority ?? 0,
-        enabled: input.enabled ?? true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    };
-}
-/**
- * Get rules for a project
- */
-export async function getProjectRules(projectId) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const results = await sqliteDb.select()
-        .from(schema.placeRules)
-        .where(eq(schema.placeRules.projectId, projectId))
-        .orderBy(desc(schema.placeRules.priority));
-    return results.map((row) => ({
-        id: row.id,
-        projectId: row.project_id,
-        name: row.name,
-        placeType: (row.place_type || row.placeType || 'custom'),
-        matchTool: row.match_tool || row.matchTool,
-        matchKeyword: row.match_keyword || row.matchKeyword,
-        matchTag: row.match_tag || row.matchTag,
-        matchMemoryType: row.match_memory_type || row.matchMemoryType,
-        priority: row.priority ?? 0,
-        enabled: row.enabled === 1 || row.enabled === true,
-        createdAt: new Date(row.created_at || Date.now()),
-        updatedAt: new Date(row.updated_at || Date.now()),
-    }));
-}
-/**
- * Check if a rule matches the input
- */
-export function matchesRule(rule, input) {
-    // Check tool match
-    if (rule.matchTool && input.toolName) {
-        if (input.toolName.toLowerCase() !== rule.matchTool.toLowerCase()) {
-            return false;
-        }
-    }
-    // Check keyword match
-    if (rule.matchKeyword && input.content) {
-        const contentLower = input.content.toLowerCase();
-        if (!contentLower.includes(rule.matchKeyword.toLowerCase())) {
-            return false;
-        }
-    }
-    // Check tag match
-    if (rule.matchTag && input.tags) {
-        const hasTag = input.tags.some(t => t.toLowerCase() === rule.matchTag.toLowerCase());
-        if (!hasTag) {
-            return false;
-        }
-    }
-    // Check memory type match
-    if (rule.matchMemoryType && input.memoryType) {
-        if (input.memoryType.toLowerCase() !== rule.matchMemoryType.toLowerCase()) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Find matching place for a memory based on rules
- */
-export async function findMatchingPlace(projectId, input) {
-    const rules = await getProjectRules(projectId);
-    // Sort by priority (highest first)
-    const sortedRules = rules
-        .filter(r => r.enabled)
-        .sort((a, b) => b.priority - a.priority);
-    for (const rule of sortedRules) {
-        if (matchesRule(rule, input)) {
-            logger.info(`[PlaceRules] Matched rule "${rule.name}" -> ${rule.placeType}`);
-            return rule.placeType;
-        }
-    }
-    return null;
-}
-/**
- * Initialize default rules for a project
- */
-export async function initializeDefaultRules(projectId) {
-    const created = [];
-    for (const ruleConfig of DEFAULT_RULES) {
-        const rule = await createPlaceRule({
-            projectId,
-            ...ruleConfig,
-        });
-        created.push(rule);
-    }
-    logger.info(`[PlaceRules] Initialized ${created.length} default rules for project: ${projectId}`);
-    return created;
-}
-/**
- * Delete a rule
- */
-export async function deletePlaceRule(id) {
-    const db = await getDb();
-    if (!db)
-        return false;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    await sqliteDb.delete(schema.placeRules).where(eq(schema.placeRules.id, id));
-    logger.info(`[PlaceRules] Deleted rule: ${id}`);
-    return true;
-}
-/**
- * Update a rule
- */
-export async function updatePlaceRule(id, updates) {
-    const db = await getDb();
-    if (!db)
-        return null;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const updateData = {};
-    if (updates.name !== undefined)
-        updateData.name = updates.name;
-    if (updates.placeType !== undefined)
-        updateData.placeType = updates.placeType;
-    if (updates.matchTool !== undefined)
-        updateData.matchTool = updates.matchTool;
-    if (updates.matchKeyword !== undefined)
-        updateData.matchKeyword = updates.matchKeyword;
-    if (updates.matchTag !== undefined)
-        updateData.matchTag = updates.matchTag;
-    if (updates.matchMemoryType !== undefined)
-        updateData.matchMemoryType = updates.matchMemoryType;
-    if (updates.priority !== undefined)
-        updateData.priority = updates.priority;
-    if (updates.enabled !== undefined)
-        updateData.enabled = updates.enabled;
-    if (Object.keys(updateData).length === 0)
-        return null;
-    await sqliteDb.update(schema.placeRules)
-        .set(updateData)
-        .where(eq(schema.placeRules.id, id));
-    const result = await sqliteDb.select()
-        .from(schema.placeRules)
-        .where(eq(schema.placeRules.id, id))
-        .limit(1);
-    if (result.length === 0)
-        return null;
-    const row = result[0];
-    return {
-        id: row.id,
-        projectId: row.project_id,
-        name: row.name,
-        placeType: row.place_type,
-        matchTool: row.match_tool,
-        matchKeyword: row.match_keyword,
-        matchTag: row.match_tag,
-        matchMemoryType: row.match_memory_type,
-        priority: row.priority,
-        enabled: row.enabled === 1 || row.enabled === true,
-        createdAt: new Date(row.created_at),
-        updatedAt: new Date(row.updated_at),
-    };
-}
-//# sourceMappingURL=rules.js.map

package/dist/core/places/walking.d.ts

@@ -1,56 +0,0 @@
-/**
- * Walking Interface - Sequential memory retrieval through places
- *
- * Implements Method of Loci walking through memory places:
- * - Walk single place to get memories in order
- * - Walk all places for full tour
- * - Token budget handling with TOON compression
- */
-import { type Place } from './places.js';
-export interface WalkOptions {
-    tokenBudget?: number;
-    maxMemoriesPerPlace?: number;
-    includePurpose?: boolean;
-    compressWithToon?: boolean;
-}
-export interface WalkResult {
-    place: Place;
-    memories: MemorySummary[];
-    totalTokens: number;
-    truncated: boolean;
-}
-export interface MemorySummary {
-    id: string;
-    content: string;
-    type: string;
-    tags: string[];
-    createdAt: string;
-}
-/**
- * Walk through a single place
- */
-export declare function walkPlace(projectId: string, placeType: string, options?: WalkOptions): Promise<WalkResult | null>;
-/**
- * Walk through all places in loci order
- */
-export declare function walkAllPlaces(projectId: string, options?: WalkOptions): Promise<WalkResult[]>;
-/**
- * Quick tour - just place names and purposes (minimal tokens)
- */
-export declare function quickTour(projectId: string): Promise<{
-    places: {
-        name: string;
-        purpose: string;
-        memoryCount: number;
-    }[];
-    totalMemories: number;
-}>;
-/**
- * Get context summary for a place (for injection)
- */
-export declare function getPlaceContext(projectId: string, placeType: string, maxTokens?: number): Promise<string>;
-/**
- * Full context for session start (all places)
- */
-export declare function getFullWalkingContext(projectId: string, maxTokens?: number): Promise<string>;
-//# sourceMappingURL=walking.d.ts.map