@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/commands-v2/handlers/reset.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reset Command for REPL V2
+ *
+ * Clears the conversation history while staying in the current project.
+ * Options:
+ * - Reset & reload context: Clear messages, refresh COMPILR.md
+ * - Reset only: Clear messages, keep current context
+ */
+import type { CommandHandlerV2 } from '../types.js';
+export declare const resetCommand: CommandHandlerV2;
+export declare const resetCommands: CommandHandlerV2[];

package/dist/commands-v2/handlers/reset.js

@@ -0,0 +1,118 @@
+/**
+ * Reset Command for REPL V2
+ *
+ * Clears the conversation history while staying in the current project.
+ * Options:
+ * - Reset & reload context: Clear messages, refresh COMPILR.md
+ * - Reset only: Clear messages, keep current context
+ */
+import { ResetOverlayV2, } from '../../ui/overlay/impl/reset-overlay-v2.js';
+import { getCurrentProject } from '../../tools/project-db.js';
+import { getProjectSessionManager } from '../../session/index.js';
+import { archiveCurrentSession } from './session.js';
+// =============================================================================
+// Reset Command
+// =============================================================================
+export const resetCommand = {
+    name: 'reset',
+    aliases: ['clear-context'],
+    description: 'Clear conversation and optionally reload project context',
+    details: 'Starts a fresh conversation within the current project. Previous session is archived to history. Use this when you want to start over without switching projects.',
+    examples: [{ code: '/reset' }],
+    interactions: [
+        'j/k to navigate options',
+        'Enter to select',
+        'Esc to cancel',
+    ],
+    async execute(_args, ctx) {
+        if (!ctx.agent) {
+            ctx.ui.print({ type: 'error', message: 'No agent connected. Cannot reset.' });
+            return true;
+        }
+        // Get current project info
+        const currentProject = getCurrentProject();
+        const projectName = currentProject?.displayName ?? 'Global';
+        // Get current session stats
+        const history = ctx.agent.getHistory();
+        const messageCount = history.length;
+        const contextManager = ctx.agent.getContextManager();
+        const tokenCount = contextManager?.getTokenCount();
+        // Show reset overlay
+        const overlay = new ResetOverlayV2({
+            projectName,
+            messageCount,
+            tokenCount,
+        });
+        const result = await ctx.ui.showOverlay(overlay);
+        if (!result || result.option === 'cancel') {
+            ctx.ui.print({ type: 'info', message: 'Reset cancelled.' });
+            return true;
+        }
+        const projectId = currentProject?.id ?? null;
+        // Handle delete-history option separately
+        if (result.option === 'delete-history') {
+            const psm = getProjectSessionManager();
+            try {
+                const deletedCount = await psm.deleteProjectHistory(projectId, false);
+                if (deletedCount > 0) {
+                    ctx.ui.print({ type: 'success', message: `Deleted ${String(deletedCount)} archived session${deletedCount !== 1 ? 's' : ''}.` });
+                }
+                else {
+                    ctx.ui.print({ type: 'info', message: 'No archived sessions to delete.' });
+                }
+            }
+            catch {
+                ctx.ui.print({ type: 'error', message: 'Failed to delete session history.' });
+            }
+            return true;
+        }
+        // Archive current session before resetting
+        try {
+            await archiveCurrentSession();
+            ctx.ui.print({ type: 'info', message: 'Previous session archived.' });
+        }
+        catch {
+            // Silently continue - archiving is best-effort
+        }
+        // Clear the agent history - both default agent and all team agents
+        ctx.agent.clearHistory();
+        // Clear restored history (Ctrl+R view)
+        ctx.ui.setRestoredHistory([]);
+        // If we have a team, clear all team agent histories too
+        if (ctx.team) {
+            ctx.team.clearAllHistories();
+            ctx.ui.print({ type: 'info', message: `Team context cleared (${String(ctx.team.size)} agents)` });
+        }
+        // Clear all message queues
+        if (ctx.clearAllQueues) {
+            const clearedCount = ctx.clearAllQueues();
+            if (clearedCount > 0) {
+                ctx.ui.print({ type: 'info', message: `${String(clearedCount)} queued message${clearedCount !== 1 ? 's' : ''} cleared` });
+            }
+        }
+        if (result.option === 'reset-reload') {
+            // Reset & reload context - need to refresh project context
+            // This is handled by creating a new agent with fresh context
+            // For now, we just clear history. Full context refresh requires
+            // recreating the agent (to be implemented in Phase 2 integration)
+            ctx.ui.print({ type: 'success', message: 'Conversation cleared. Project context refreshed.' });
+            ctx.ui.print({ type: 'info', message: 'Note: Full context reload requires CLI restart for now.' });
+        }
+        else {
+            // Reset only - just clear messages
+            ctx.ui.print({ type: 'success', message: 'Conversation cleared. Context preserved.' });
+        }
+        // Save the fresh session state
+        const psm = getProjectSessionManager();
+        const state = ctx.agent.serialize();
+        await psm.saveProjectSession(projectId, currentProject?.displayName ?? null, state);
+        ctx.ui.print({ type: 'info', message: 'Ready for a fresh conversation.' });
+        return true;
+    },
+};
+// =============================================================================
+// Export
+// =============================================================================
+export const resetCommands = [
+    resetCommand,
+];

package/dist/commands-v2/handlers/session.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Session Commands for REPL V2
+ *
+ * Commands for managing session persistence and resumption.
+ * Sessions are now bound to projects - each project has its own session.
+ */
+import type { CommandHandlerV2 } from '../types.js';
+import type { AgentState, SessionInfo, AnchorScope, AnchorClearOptions, AnchorPriority, Message } from '@compilr-dev/sdk';
+import type { PrintableItem } from '../../ui/terminal-ui.js';
+import { type ProjectSession } from '../../session/index.js';
+import type { AgentTeam, AgentTeamConfig } from '../../multi-agent/index.js';
+/**
+ * Convert restored messages to PrintableItems for Ctrl+R history view.
+ * Filters out noise (thinking blocks, pure tool_result messages) and
+ * maps each message to the appropriate PrintableItem type.
+ */
+export declare function convertMessagesToItems(messages: Message[]): PrintableItem[];
+/**
+ * Save the current agent state to the current project's session.
+ * Called after each successful agent response.
+ */
+export declare function saveCurrentSession(state: AgentState): Promise<void>;
+/**
+ * Load the session for the current or specified project.
+ * Returns null if no session exists.
+ */
+export declare function loadProjectSession(projectId: number | null): Promise<ProjectSession | null>;
+/**
+ * Check if the current project has a saved session.
+ */
+export declare function hasCurrentProjectSession(): boolean;
+/**
+ * Archive the current session before starting fresh.
+ */
+export declare function archiveCurrentSession(): Promise<boolean>;
+/**
+ * Save the current team state to the current project.
+ * Called after each successful agent response (alongside session save).
+ * Also saves shared context and artifact store.
+ */
+export declare function saveCurrentTeam(team: AgentTeam): void;
+/**
+ * Load the team for the current project.
+ * Returns null if no team exists.
+ * The checkpointer automatically loads shared context and artifact store.
+ */
+export declare function loadCurrentTeam(agentFactory: AgentTeamConfig['agentFactory'], onEvent?: AgentTeamConfig['onEvent']): AgentTeam | null;
+/**
+ * Check if the current project has a saved team.
+ */
+export declare function hasCurrentTeam(): boolean;
+/**
+ * Delete the team for the current project.
+ */
+export declare function deleteCurrentTeam(): boolean;
+/**
+ * Check if there are any recent sessions (within last 24 hours).
+ */
+export declare function hasRecentSession(): Promise<boolean>;
+/**
+ * Get the most recent session info.
+ */
+export declare function getMostRecentSession(): Promise<SessionInfo | null>;
+/**
+ * Checkpoint the current project's session before switching.
+ * Returns the old project ID if a checkpoint was made.
+ */
+export declare function checkpointBeforeSwitch(agent: {
+    serialize: () => AgentState;
+} | null): Promise<number | null>;
+/**
+ * Load and restore a session for a project.
+ * Returns the session if restored, null if no session or fresh start.
+ */
+export declare function loadAndRestoreSession(projectId: number | null, agent: {
+    setHistory: (messages: AgentState['messages'], options?: {
+        turnCount?: number;
+    }) => Promise<void>;
+} | null, mode?: 'auto' | 'ask' | 'fresh'): Promise<ProjectSession | null>;
+/**
+ * Handle project context switch after an overlay that may have changed projects.
+ * Checkpoints the old session, loads the new one, and refreshes context.
+ * Also handles team switching - saves old team and loads new project's team.
+ *
+ * @param oldProjectId - The project ID before the overlay was shown
+ * @param agent - The agent instance (for checkpoint/restore/anchors)
+ * @param teamOptions - Optional team switching options
+ * @returns Object with switch info, or null if no switch occurred
+ */
+export declare function handleProjectSwitch(oldProjectId: number | null, agent: {
+    serialize: () => AgentState;
+    setHistory: (messages: AgentState['messages'], options?: {
+        turnCount?: number;
+    }) => Promise<unknown>;
+    clearHistory: () => unknown;
+    clearAnchors?: (options?: AnchorClearOptions) => number;
+    addAnchor?: (input: {
+        id?: string;
+        content: string;
+        priority: AnchorPriority;
+        scope: AnchorScope;
+        tags?: string[];
+    }) => unknown;
+} | null, teamOptions?: {
+    team: AgentTeam | null;
+    agentFactory: AgentTeamConfig['agentFactory'];
+    onEvent?: AgentTeamConfig['onEvent'];
+}): Promise<{
+    switched: boolean;
+    oldProjectId: number | null;
+    newProjectId: number | null;
+    sessionRestored: boolean;
+    messageCount: number;
+    restoredMessages?: AgentState['messages'];
+    contextRefreshed: boolean;
+    contextMessage?: string;
+    newTeam?: AgentTeam;
+} | null>;
+/**
+ * Get the current project ID for tracking before overlay.
+ * Use with handleProjectSwitch after overlay closes.
+ */
+export declare function getCurrentProjectIdForTracking(): number | null;
+export interface ProjectContextRefreshResult {
+    /** Whether COMPILR.md was found and loaded */
+    memoryLoaded: boolean;
+    /** The COMPILR.md content (if found) */
+    memoryContent?: string;
+    /** The file path that was loaded */
+    memoryPath?: string;
+    /** Whether guided mode context was generated */
+    guidedContextGenerated: boolean;
+    /** The guided mode context (if applicable) */
+    guidedContext?: string;
+    /** Number of project anchors loaded */
+    anchorsLoaded: number;
+    /** Combined context message for injection */
+    contextMessage: string;
+}
+/**
+ * Refresh project context after switching projects.
+ * Loads COMPILR.md, generates guided context, and prepares anchor updates.
+ *
+ * @param projectId - The new project's ID (null for global)
+ * @param projectPath - The new project's path (for loading COMPILR.md)
+ * @returns Context refresh result with message to inject
+ */
+export declare function refreshProjectContext(projectId: number | null, projectPath: string | null): Promise<ProjectContextRefreshResult>;
+/**
+ * Get anchor data for the new project (to update agent's anchor manager).
+ */
+export declare function getProjectAnchors(projectId: number | null): Promise<Array<{
+    id: string;
+    content: string;
+    priority: AnchorPriority;
+    scope: AnchorScope;
+    tags: string[];
+    projectId?: string;
+}>>;
+export declare const resumeCommand: CommandHandlerV2;
+export declare const sessionCommands: CommandHandlerV2[];