nastech-app 1.0.0

package/sources/sync/storageTypes.spec.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { MetadataSchema } from './storageTypes';
+
+describe('MetadataSchema', () => {
+    it('preserves archive lifecycle metadata', () => {
+        const metadata = MetadataSchema.parse({
+            path: '/tmp/project',
+            host: 'local-machine',
+            startedBy: 'daemon',
+            startedFromDaemon: true,
+            lifecycleState: 'archived',
+            lifecycleStateSince: 123,
+            archivedBy: 'cli',
+            archiveReason: 'User terminated',
+        });
+
+        expect(metadata.startedBy).toBe('daemon');
+        expect(metadata.startedFromDaemon).toBe(true);
+        expect(metadata.lifecycleState).toBe('archived');
+        expect(metadata.lifecycleStateSince).toBe(123);
+        expect(metadata.archivedBy).toBe('cli');
+        expect(metadata.archiveReason).toBe('User terminated');
+    });
+});

package/sources/sync/storageTypes.ts

@@ -0,0 +1,215 @@
+import { z } from "zod";
+
+//
+// Agent states
+//
+
+export const MetadataSchema = z.object({
+    models: z.array(z.object({
+        code: z.string(),
+        value: z.string(),
+        description: z.string().nullish(),
+    })).optional(),
+    currentModelCode: z.string().optional(),
+    operatingModes: z.array(z.object({
+        code: z.string(),
+        value: z.string(),
+        description: z.string().nullish(),
+    })).optional(),
+    currentOperatingModeCode: z.string().optional(),
+    thoughtLevels: z.array(z.object({
+        code: z.string(),
+        value: z.string(),
+        description: z.string().nullish(),
+    })).optional(),
+    currentThoughtLevelCode: z.string().optional(),
+    path: z.string(),
+    host: z.string(),
+    version: z.string().optional(),
+    name: z.string().optional(),
+    os: z.string().optional(),
+    summary: z.object({
+        text: z.string(),
+        updatedAt: z.number()
+    }).optional(),
+    machineId: z.string().optional(),
+    claudeSessionId: z.string().optional(), // Claude Code session ID
+    codexThreadId: z.string().optional(), // Codex app-server thread ID
+    tools: z.array(z.string()).optional(),
+    slashCommands: z.array(z.string()).optional(),
+    mcpServers: z.array(z.object({ name: z.string(), status: z.string() })).optional(),
+    skills: z.array(z.string()).optional(),
+    homeDir: z.string().optional(), // User's home directory on the machine
+    nastechHomeDir: z.string().optional(), // NasTech configuration directory 
+    startedFromDaemon: z.boolean().optional(),
+    hostPid: z.number().optional(), // Process ID of the session
+    startedBy: z.enum(['daemon', 'terminal']).optional(),
+    flavor: z.string().nullish(), // Session flavor/variant identifier
+    sandbox: z.any().nullish(), // Sandbox config metadata from CLI (or null when disabled)
+    dangerouslySkipPermissions: z.boolean().nullish(), // Claude --dangerously-skip-permissions mode (or null when unknown)
+    lifecycleState: z.string().optional(),
+    lifecycleStateSince: z.number().optional(),
+    archivedBy: z.string().optional(),
+    archiveReason: z.string().optional(),
+    /**
+     * Lineage for sessions created via the fork / duplicate flow.
+     * `parentSessionId` is the NasTech session this one was branched from.
+     * `forkedFromMessageId` is the in-app message id used as the rewind
+     * point (only set for "duplicate from message", not for plain fork).
+     * Both ride inside encrypted metadata so the server stays oblivious.
+     */
+    parentSessionId: z.string().optional(),
+    forkedFromMessageId: z.string().optional(),
+});
+
+export type Metadata = z.infer<typeof MetadataSchema>;
+
+export const AgentStateSchema = z.object({
+    controlledByUser: z.boolean().nullish(),
+    requests: z.record(z.string(), z.object({
+        tool: z.string(),
+        arguments: z.any(),
+        createdAt: z.number().nullish()
+    })).nullish(),
+    completedRequests: z.record(z.string(), z.object({
+        tool: z.string(),
+        arguments: z.any(),
+        createdAt: z.number().nullish(),
+        completedAt: z.number().nullish(),
+        status: z.enum(['canceled', 'denied', 'approved']),
+        reason: z.string().nullish(),
+        mode: z.string().nullish(),
+        allowedTools: z.array(z.string()).nullish(),
+        decision: z.enum(['approved', 'approved_for_session', 'denied', 'abort']).nullish()
+    })).nullish()
+});
+
+export type AgentState = z.infer<typeof AgentStateSchema>;
+
+export const TodoItemSchema = z.object({
+    content: z.string(),
+    status: z.enum(['pending', 'in_progress', 'completed']),
+    priority: z.enum(['high', 'medium', 'low']).optional(),
+    id: z.string().optional(),
+});
+
+export const TodoItemsSchema = z.array(TodoItemSchema);
+
+export type TodoItem = z.infer<typeof TodoItemSchema>;
+
+export interface Session {
+    id: string,
+    seq: number,
+    createdAt: number,
+    updatedAt: number,
+    active: boolean,
+    activeAt: number,
+    metadata: Metadata | null,
+    metadataVersion: number,
+    agentState: AgentState | null,
+    agentStateVersion: number,
+    thinking: boolean,
+    thinkingAt: number,
+    presence: "online" | number, // "online" when active, timestamp when last seen
+    todos?: TodoItem[];
+    draft?: string | null; // Local draft message, not synced to server
+    permissionMode?: string | null; // Local permission mode key, not synced to server
+    modelMode?: string | null; // Local model key, not synced to server
+    effortLevel?: string | null; // Local effort level key, not synced to server
+    // IMPORTANT: latestUsage is extracted from reducerState.latestUsage after message processing.
+    // We store it directly on Session to ensure it's available immediately on load.
+    // Do NOT store reducerState itself on Session - it's mutable and should only exist in SessionMessages.
+    latestUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreation: number;
+        cacheRead: number;
+        contextSize: number;
+        timestamp: number;
+    } | null;
+}
+
+export interface DecryptedMessage {
+    id: string,
+    seq: number | null,
+    localId: string | null,
+    content: any,
+    createdAt: number,
+}
+
+//
+// Machine states
+//
+
+export const MachineMetadataSchema = z.object({
+    host: z.string(),
+    platform: z.string(),
+    nastechCliVersion: z.string(),
+    nastechHomeDir: z.string(), // Directory for NasTech auth, settings, logs (usually .nastech/ or .nastech-dev/)
+    homeDir: z.string(), // User's home directory (matches CLI field name)
+    // Optional fields that may be added in future versions
+    username: z.string().optional(),
+    arch: z.string().optional(),
+    displayName: z.string().optional(), // Custom display name for the machine
+    // Daemon status fields
+    daemonLastKnownStatus: z.enum(['running', 'shutting-down']).optional(),
+    daemonLastKnownPid: z.number().optional(),
+    shutdownRequestedAt: z.number().optional(),
+    shutdownSource: z.enum(['nastech-app', 'nastech-cli', 'os-signal', 'unknown']).optional(),
+    cliAvailability: z.object({
+        claude: z.boolean(),
+        codex: z.boolean(),
+        gemini: z.boolean(),
+        openclaw: z.boolean(),
+        detectedAt: z.number(),
+    }).optional(),
+    resumeSupport: z.object({
+        rpcAvailable: z.boolean(),
+        requiresSameMachine: z.boolean(),
+        requiresNasTechAgentAuth: z.boolean(),
+        nastechAgentAuthenticated: z.boolean(),
+        detectedAt: z.number(),
+    }).optional(),
+});
+
+export type MachineMetadata = z.infer<typeof MachineMetadataSchema>;
+
+export interface Machine {
+    id: string;
+    seq: number;
+    createdAt: number;
+    updatedAt: number;
+    active: boolean;
+    activeAt: number;  // Changed from lastActiveAt to activeAt for consistency
+    metadata: MachineMetadata | null;
+    metadataVersion: number;
+    daemonState: any | null;  // Dynamic daemon state (runtime info)
+    daemonStateVersion: number;
+}
+
+//
+// Git Status
+//
+
+export interface GitStatus {
+    branch: string | null;
+    isDirty: boolean;
+    modifiedCount: number;
+    untrackedCount: number;
+    stagedCount: number;
+    lastUpdatedAt: number;
+    // Line change statistics - separated by staged vs unstaged
+    stagedLinesAdded: number;
+    stagedLinesRemoved: number;
+    unstagedLinesAdded: number;
+    unstagedLinesRemoved: number;
+    // Computed totals
+    linesAdded: number;      // stagedLinesAdded + unstagedLinesAdded
+    linesRemoved: number;    // stagedLinesRemoved + unstagedLinesRemoved
+    linesChanged: number;    // Total lines that were modified (added + removed)
+    // Branch tracking information (from porcelain v2)
+    upstreamBranch?: string | null; // Name of upstream branch
+    aheadCount?: number; // Commits ahead of upstream
+    behindCount?: number; // Commits behind upstream
+    stashCount?: number; // Number of stash entries
+}

package/sources/sync/suggestionCommands.ts

@@ -0,0 +1,149 @@
+/**
+ * Suggestion commands functionality for slash commands
+ * Reads commands directly from session metadata storage
+ */
+
+import Fuse from 'fuse.js';
+import { storage } from './storage';
+
+export interface CommandItem {
+    command: string;        // The command without slash (e.g., "compact")
+    description?: string;   // Optional description of what the command does
+}
+
+interface SearchOptions {
+    limit?: number;
+    threshold?: number;
+}
+
+// Commands to ignore/filter out
+export const IGNORED_COMMANDS = [
+    "add-dir",
+    "agents",
+    "config",
+    "statusline",
+    "bashes",
+    "settings",
+    "cost",
+    "doctor",
+    "exit",
+    "help",
+    "ide",
+    "init",
+    "install-github-app",
+    "memory",
+    "migrate-installer",
+    "model",
+    "pr-comments",
+    "release-notes",
+    "resume",
+    "status",
+    "bug",
+    "review",
+    "security-review",
+    "terminal-setup",
+    "upgrade",
+    "vim",
+    "permissions",
+    "hooks",
+    "export",
+    "logout",
+    "login"
+];
+
+// Default commands always available
+const DEFAULT_COMMANDS: CommandItem[] = [
+    { command: 'compact', description: 'Compact the conversation history' },
+    { command: 'clear', description: 'Clear the conversation' },
+    { command: 'mcp', description: 'Show connected MCP servers' },
+    { command: 'skills', description: 'Show available skills' },
+];
+
+// Command descriptions for known tools/commands
+const COMMAND_DESCRIPTIONS: Record<string, string> = {
+    // Default commands
+    compact: 'Compact the conversation history',
+    
+    // Common tool commands
+    help: 'Show available commands',
+    clear: 'Clear the conversation',
+    reset: 'Reset the session',
+    export: 'Export conversation',
+    debug: 'Show debug information',
+    status: 'Show connection status',
+    stop: 'Stop current operation',
+    abort: 'Abort current operation',
+    cancel: 'Cancel current operation',
+    
+    // Add more descriptions as needed
+};
+
+// Get commands from session metadata
+function getCommandsFromSession(sessionId: string): CommandItem[] {
+    const state = storage.getState();
+    const session = state.sessions[sessionId];
+    if (!session || !session.metadata) {
+        return DEFAULT_COMMANDS;
+    }
+
+    const commands: CommandItem[] = [...DEFAULT_COMMANDS];
+    
+    // Add commands from metadata.slashCommands (filter with ignore list)
+    if (session.metadata.slashCommands) {
+        for (const cmd of session.metadata.slashCommands) {
+            // Skip if in ignore list
+            if (IGNORED_COMMANDS.includes(cmd)) continue;
+            
+            // Check if it's already in default commands
+            if (!commands.find(c => c.command === cmd)) {
+                commands.push({
+                    command: cmd,
+                    description: COMMAND_DESCRIPTIONS[cmd]  // Optional description
+                });
+            }
+        }
+    }
+    
+    return commands;
+}
+
+// Main export: search commands with fuzzy matching
+export async function searchCommands(
+    sessionId: string,
+    query: string,
+    options: SearchOptions = {}
+): Promise<CommandItem[]> {
+    const { limit = 10, threshold = 0.3 } = options;
+    
+    // Get commands from session metadata (no caching)
+    const commands = getCommandsFromSession(sessionId);
+    
+    // If query is empty, return all commands
+    if (!query || query.trim().length === 0) {
+        return commands.slice(0, limit);
+    }
+    
+    // Setup Fuse for fuzzy search
+    const fuseOptions = {
+        keys: [
+            { name: 'command', weight: 0.7 },
+            { name: 'description', weight: 0.3 }
+        ],
+        threshold,
+        includeScore: true,
+        shouldSort: true,
+        minMatchCharLength: 1,
+        ignoreLocation: true,
+        useExtendedSearch: true
+    };
+    
+    const fuse = new Fuse(commands, fuseOptions);
+    const results = fuse.search(query, { limit });
+    
+    return results.map(result => result.item);
+}
+
+// Get all available commands for a session
+export function getAllCommands(sessionId: string): CommandItem[] {
+    return getCommandsFromSession(sessionId);
+}

package/sources/sync/suggestionFile.ts

@@ -0,0 +1,206 @@
+/**
+ * Suggestion file search functionality using ripgrep for fast file discovery
+ * Provides fuzzy search capabilities with in-memory caching for autocomplete suggestions
+ */
+
+import Fuse from 'fuse.js';
+import { sessionRipgrep } from './ops';
+import { AsyncLock } from '@/utils/lock';
+
+export interface FileItem {
+    fileName: string;
+    filePath: string;
+    fullPath: string;
+    fileType: 'file' | 'folder';
+}
+
+interface SearchOptions {
+    limit?: number;
+    threshold?: number;
+}
+
+interface SessionCache {
+    files: FileItem[];
+    fuse: Fuse<FileItem> | null;
+    lastRefresh: number;
+    refreshLock: AsyncLock;
+}
+
+class FileSearchCache {
+    private sessions = new Map<string, SessionCache>();
+    private cacheTimeout = 5 * 60 * 1000; // 5 minutes
+
+    private getOrCreateSessionCache(sessionId: string): SessionCache {
+        let cache = this.sessions.get(sessionId);
+        if (!cache) {
+            cache = {
+                files: [],
+                fuse: null,
+                lastRefresh: 0,
+                refreshLock: new AsyncLock()
+            };
+            this.sessions.set(sessionId, cache);
+        }
+        return cache;
+    }
+
+    private initializeFuse(cache: SessionCache) {
+        if (cache.files.length === 0) {
+            cache.fuse = null;
+            return;
+        }
+
+        const fuseOptions = {
+            keys: [
+                { name: 'fileName', weight: 0.7 },  // Higher weight for file/directory name
+                { name: 'fullPath', weight: 0.3 }   // Lower weight for full path
+            ],
+            threshold: 0.3,
+            includeScore: true,
+            shouldSort: true,
+            minMatchCharLength: 1,
+            ignoreLocation: true,
+            useExtendedSearch: true,
+            // Allow fuzzy matching on slashes for directories
+            distance: 100
+        };
+
+        cache.fuse = new Fuse(cache.files, fuseOptions);
+    }
+
+    private async ensureCacheValid(sessionId: string): Promise<void> {
+        const cache = this.getOrCreateSessionCache(sessionId);
+        const now = Date.now();
+        
+        // Check if cache needs refresh
+        if (now - cache.lastRefresh <= this.cacheTimeout && cache.files.length > 0) {
+            return; // Cache is still valid
+        }
+
+        // Use lock to prevent concurrent refreshes for this session
+        await cache.refreshLock.inLock(async () => {
+            // Double-check after acquiring lock
+            const currentTime = Date.now();
+            if (currentTime - cache.lastRefresh < 1000) { // Skip if refreshed within last second
+                return;
+            }
+
+            console.log(`FileSearchCache: Refreshing file cache for session ${sessionId}...`);
+
+            // Use ripgrep to get all files in the project
+            const response = await sessionRipgrep(
+                sessionId,
+                ['--files', '--follow'],
+                undefined
+            );
+
+            if (!response.success || !response.stdout) {
+                console.error('FileSearchCache: Failed to fetch files', response.error);
+                console.log(response);
+                return;
+            }
+
+            // Parse the output into file items
+            const filePaths = response.stdout
+                .split('\n')
+                .filter(path => path.trim().length > 0);
+
+            // Clear existing files
+            cache.files = [];
+
+            // Add all files
+            filePaths.forEach(path => {
+                const parts = path.split('/');
+                const fileName = parts[parts.length - 1] || path;
+                const filePath = parts.slice(0, -1).join('/') || '';
+
+                cache.files.push({
+                    fileName,
+                    filePath: filePath ? filePath + '/' : '',
+                    fullPath: path,
+                    fileType: 'file' as const
+                });
+            });
+
+            // Add unique directories with trailing slash
+            const directories = new Set<string>();
+            filePaths.forEach(path => {
+                const parts = path.split('/');
+                for (let i = 1; i <= parts.length - 1; i++) {
+                    const dirPath = parts.slice(0, i).join('/');
+                    if (dirPath) {
+                        directories.add(dirPath);
+                    }
+                }
+            });
+
+            directories.forEach(dirPath => {
+                const parts = dirPath.split('/');
+                const dirName = parts[parts.length - 1] + '/';  // Add trailing slash to directory name
+                const parentPath = parts.slice(0, -1).join('/');
+
+                cache.files.push({
+                    fileName: dirName,
+                    filePath: parentPath ? parentPath + '/' : '',
+                    fullPath: dirPath + '/',  // Add trailing slash to full path
+                    fileType: 'folder'
+                });
+            });
+
+            cache.lastRefresh = Date.now();
+            this.initializeFuse(cache);
+
+            console.log(`FileSearchCache: Cached ${cache.files.length} files and directories for session ${sessionId}`);
+        });
+    }
+
+    async search(sessionId: string, query: string, options: SearchOptions = {}): Promise<FileItem[]> {
+        await this.ensureCacheValid(sessionId);
+        const cache = this.getOrCreateSessionCache(sessionId);
+
+        if (!cache.fuse || cache.files.length === 0) {
+            return [];
+        }
+
+        const { limit = 10, threshold = 0.3 } = options;
+
+        // If query is empty, return most recently modified files
+        if (!query || query.trim().length === 0) {
+            return cache.files.slice(0, limit);
+        }
+
+        // Perform fuzzy search
+        const searchOptions = {
+            limit,
+            threshold
+        };
+
+        const results = cache.fuse.search(query, searchOptions);
+        return results.map(result => result.item);
+    }
+
+    getAllFiles(sessionId: string): FileItem[] {
+        const cache = this.sessions.get(sessionId);
+        return cache ? [...cache.files] : [];
+    }
+
+    clearCache(sessionId?: string): void {
+        if (sessionId) {
+            this.sessions.delete(sessionId);
+        } else {
+            this.sessions.clear();
+        }
+    }
+}
+
+// Export singleton instance
+export const fileSearchCache = new FileSearchCache();
+
+// Main export: search files with fuzzy matching
+export async function searchFiles(
+    sessionId: string,
+    query: string,
+    options: SearchOptions = {}
+): Promise<FileItem[]> {
+    return fileSearchCache.search(sessionId, query, options);
+}