squish-memory 1.2.0 → 1.2.1

package/dist/core/places/places.js

@@ -1,314 +0,0 @@
-/**
- * Places Module - Spatial memory organization
- *
- * Provides spatial "places" for memory organization:
- * - Inbox: New memories, unprocessed
- * - Ref: Reference, patterns, research
- * - WIP: Active work, implementations
- * - Sandbox: Experiments, tests
- * - Board: Decisions, planning, roadmap
- * - Sparks: 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: 'Inbox', placeType: 'inbox', sortOrder: 0, description: 'New memories, unprocessed', purpose: 'Quick inbox for incoming memories' },
-    { name: 'Ref', placeType: 'ref', sortOrder: 1, description: 'Reference, patterns, research', purpose: 'Reference knowledge and learned patterns' },
-    { name: 'WIP', placeType: 'wip', sortOrder: 2, description: 'Active work, implementations', purpose: 'Active development and recent changes' },
-    { name: 'Sandbox', placeType: 'sandbox', sortOrder: 3, description: 'Experiments, tests', purpose: 'Testing and exploration results' },
-    { name: 'Board', placeType: 'board', sortOrder: 4, description: 'Decisions, planning, roadmap', purpose: 'Project direction and decisions' },
-    { name: 'Sparks', placeType: 'sparks', sortOrder: 5, description: 'Ideas, future concepts', purpose: 'Brainstorming and upcoming plans' },
-    { name: 'Archive', placeType: 'archive', sortOrder: 6, description: 'Completed, historical', 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,
-        sortOrder: input.sortOrder ?? 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,
-        sortOrder: input.sortOrder ?? 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,
-        sortOrder: row.sort_order ?? row.sortOrder ?? 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 sort_order
- */
-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.sortOrder);
-    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,
-        sortOrder: row.sort_order ?? row.sortOrder ?? 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,
-        sortOrder: row.sort_order ?? row.sortOrder ?? 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.sortOrder !== undefined)
-        updateData.sortOrder = input.sortOrder;
-    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,
-            sortOrder: placeConfig.sortOrder,
-            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, sortOrder) {
-    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.sortOrder, sortOrder)))
-        .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,
-        sortOrder: row.sort_order ?? row.sortOrder ?? 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 = [
-    // WIP - Implementation, code, fixes
-    { name: 'Write to WIP', placeType: 'wip', matchTool: 'Write', priority: 100 },
-    { name: 'Edit to WIP', placeType: 'wip', matchTool: 'Edit', priority: 100 },
-    { name: 'MultiEdit to WIP', placeType: 'wip', matchTool: 'MultiEdit', priority: 100 },
-    { name: 'Fix keyword to WIP', placeType: 'wip', matchKeyword: 'fix', priority: 80 },
-    { name: 'Bug keyword to WIP', placeType: 'wip', matchKeyword: 'bug', priority: 80 },
-    // Sandbox - Experiments, tests
-    { name: 'Test to Sandbox', placeType: 'sandbox', matchTool: 'Bash', matchKeyword: 'test', priority: 90 },
-    { name: 'Test tag to Sandbox', placeType: 'sandbox', matchTag: 'test', priority: 85 },
-    // Board - Decisions, planning
-    { name: 'Task to Board', placeType: 'board', matchTool: 'Task', priority: 100 },
-    { name: 'TodoWrite to Board', placeType: 'board', matchTool: 'TodoWrite', priority: 100 },
-    { name: 'Decision keyword to Board', placeType: 'board', matchKeyword: 'decided', priority: 70 },
-    { name: 'Planning keyword to Board', placeType: 'board', matchKeyword: 'will implement', priority: 70 },
-    // Ref - Research, patterns
-    { name: 'Search to Ref', placeType: 'ref', matchTool: 'grep', priority: 90 },
-    { name: 'WebFetch to Ref', placeType: 'ref', matchTool: 'WebFetch', priority: 85 },
-    { name: 'Research keyword to Ref', placeType: 'ref', matchKeyword: 'research', priority: 80 },
-    { name: 'Pattern keyword to Ref', placeType: 'ref', matchKeyword: 'pattern', priority: 75 },
-    // Sparks - Ideas, future
-    { name: 'Idea keyword to Sparks', placeType: 'sparks', matchKeyword: 'idea', priority: 80 },
-    { name: 'Explore keyword to Sparks', placeType: 'sparks', matchKeyword: 'explore', priority: 75 },
-    { name: 'Future keyword to Sparks', placeType: 'sparks', 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 place 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;
-    compressWithCompression?: 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 sort 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