@stanco323/oh-my-claude-code 4.10.3

package/dist/features/rate-limit-wait/types.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Rate Limit Wait - Type Definitions
+ *
+ * Types for the rate limit auto-resume daemon.
+ * Reference: https://github.com/EvanOman/cc-wait
+ */
+import type { UsageErrorReason } from '../../hud/types.js';
+export interface RateLimitStatus {
+    /** Whether rate limited on 5-hour window */
+    fiveHourLimited: boolean;
+    /** Whether rate limited on weekly window */
+    weeklyLimited: boolean;
+    /** Whether rate limited on monthly window (if available from API) */
+    monthlyLimited: boolean;
+    /** Combined: true if any limit is hit */
+    isLimited: boolean;
+    /** When 5-hour limit resets */
+    fiveHourResetsAt: Date | null;
+    /** When weekly limit resets */
+    weeklyResetsAt: Date | null;
+    /** When monthly limit resets (if available from API) */
+    monthlyResetsAt: Date | null;
+    /** Earliest reset time */
+    nextResetAt: Date | null;
+    /** Time until reset in milliseconds */
+    timeUntilResetMs: number | null;
+    /** Latest 5-hour usage percentage if available */
+    fiveHourPercent?: number;
+    /** Latest weekly usage percentage if available */
+    weeklyPercent?: number;
+    /** Latest monthly usage percentage if available */
+    monthlyPercent?: number;
+    /** Error reason from the underlying usage API call, if any */
+    apiErrorReason?: UsageErrorReason;
+    /** Whether the returned usage data came from stale cache */
+    usingStaleData?: boolean;
+    /** Last check timestamp */
+    lastCheckedAt: Date;
+}
+export interface TmuxPane {
+    /** Pane ID (e.g., "%0") */
+    id: string;
+    /** Session name */
+    session: string;
+    /** Window index */
+    windowIndex: number;
+    /** Window name */
+    windowName: string;
+    /** Pane index within window */
+    paneIndex: number;
+    /** Pane title (if set) */
+    title?: string;
+    /** Whether this pane is currently active */
+    isActive: boolean;
+}
+export interface PaneAnalysisResult {
+    /** Whether this pane appears to have Claude Code */
+    hasClaudeCode: boolean;
+    /** Whether rate limit message is visible */
+    hasRateLimitMessage: boolean;
+    /** Whether the pane appears blocked (waiting for input) */
+    isBlocked: boolean;
+    /** Detected rate limit type if any */
+    rateLimitType?: 'five_hour' | 'weekly' | 'unknown';
+    /** Confidence level (0-1) */
+    confidence: number;
+}
+export interface BlockedPane extends TmuxPane {
+    /** Analysis result for this pane */
+    analysis: PaneAnalysisResult;
+    /** When this pane was first detected as blocked */
+    firstDetectedAt: Date;
+    /** Whether resume has been attempted */
+    resumeAttempted: boolean;
+    /** Whether resume was successful */
+    resumeSuccessful?: boolean;
+}
+export interface DaemonState {
+    /** Whether daemon is running */
+    isRunning: boolean;
+    /** Process ID if running */
+    pid: number | null;
+    /** When daemon started */
+    startedAt: Date | null;
+    /** Last poll timestamp */
+    lastPollAt: Date | null;
+    /** Current rate limit status */
+    rateLimitStatus: RateLimitStatus | null;
+    /** Currently tracked blocked panes */
+    blockedPanes: BlockedPane[];
+    /** Panes that have been resumed (to avoid re-sending) */
+    resumedPaneIds: string[];
+    /** Total resume attempts */
+    totalResumeAttempts: number;
+    /** Successful resume count */
+    successfulResumes: number;
+    /** Error count */
+    errorCount: number;
+    /** Last error message */
+    lastError?: string;
+}
+export interface DaemonConfig {
+    /** Polling interval in milliseconds (default: 60000 = 1 minute) */
+    pollIntervalMs?: number;
+    /** Number of pane lines to capture for analysis (default: 15) */
+    paneLinesToCapture?: number;
+    /** Whether to log verbose output (default: false) */
+    verbose?: boolean;
+    /** State file path (default: XDG-aware global OMC state path) */
+    stateFilePath?: string;
+    /** PID file path (default: XDG-aware global OMC state path) */
+    pidFilePath?: string;
+    /** Log file path (default: XDG-aware global OMC state path) */
+    logFilePath?: string;
+}
+export interface ResumeResult {
+    /** Pane ID */
+    paneId: string;
+    /** Whether resume was successful */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Timestamp */
+    timestamp: Date;
+}
+export interface DaemonCommand {
+    action: 'start' | 'stop' | 'status' | 'detect';
+    options?: DaemonConfig;
+}
+export interface DaemonResponse {
+    success: boolean;
+    message: string;
+    state?: DaemonState;
+    error?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/features/rate-limit-wait/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/features/rate-limit-wait/types.ts"],"names":[],"mappings":"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"}

package/dist/features/rate-limit-wait/types.js

@@ -0,0 +1,8 @@
+/**
+ * Rate Limit Wait - Type Definitions
+ *
+ * Types for the rate limit auto-resume daemon.
+ * Reference: https://github.com/EvanOman/cc-wait
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/features/rate-limit-wait/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/features/rate-limit-wait/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/features/session-history-search/index.d.ts

@@ -0,0 +1,6 @@
+import type { SessionHistorySearchOptions, SessionHistorySearchReport } from './types.js';
+declare function parseSinceSpec(since?: string): number | undefined;
+export declare function searchSessionHistory(rawOptions: SessionHistorySearchOptions): Promise<SessionHistorySearchReport>;
+export { parseSinceSpec };
+export type { SessionHistoryMatch, SessionHistorySearchOptions, SessionHistorySearchReport, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/features/session-history-search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/features/session-history-search/index.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAEV,2BAA2B,EAC3B,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAiCpB,iBAAS,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAsB1D;AA8aD,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,2BAA2B,GACtC,OAAO,CAAC,0BAA0B,CAAC,CA8DrC;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,YAAY,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,YAAY,CAAC"}

package/dist/features/session-history-search/index.js

@@ -0,0 +1,480 @@
+import { execSync } from 'child_process';
+import { createReadStream, existsSync, readdirSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join, normalize, resolve } from 'path';
+import { createInterface } from 'readline';
+import { resolveToWorktreeRoot, validateSessionId, validateWorkingDirectory, getOmcRoot, } from '../../lib/worktree-paths.js';
+const DEFAULT_LIMIT = 10;
+const DEFAULT_CONTEXT_CHARS = 120;
+function getClaudeConfigDir() {
+    return process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+}
+function compactWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function normalizeForSearch(value, caseSensitive) {
+    const compacted = compactWhitespace(value);
+    return caseSensitive ? compacted : compacted.toLowerCase();
+}
+function parseSinceSpec(since) {
+    if (!since)
+        return undefined;
+    const trimmed = since.trim();
+    if (!trimmed)
+        return undefined;
+    const durationMatch = trimmed.match(/^(\d+)\s*([mhdw])$/i);
+    if (durationMatch) {
+        const amount = Number.parseInt(durationMatch[1], 10);
+        const unit = durationMatch[2].toLowerCase();
+        const multiplierMap = {
+            m: 60_000,
+            h: 3_600_000,
+            d: 86_400_000,
+            w: 604_800_000,
+        };
+        const multiplier = multiplierMap[unit];
+        return multiplier ? Date.now() - amount * multiplier : undefined;
+    }
+    const parsed = Date.parse(trimmed);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function encodeProjectPath(projectPath) {
+    return projectPath.replace(/[\\/]/g, '-');
+}
+function getMainRepoRoot(projectRoot) {
+    try {
+        const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        const absoluteCommonDir = resolve(projectRoot, gitCommonDir);
+        const mainRepoRoot = dirname(absoluteCommonDir);
+        return mainRepoRoot === projectRoot ? null : mainRepoRoot;
+    }
+    catch {
+        return null;
+    }
+}
+function getClaudeWorktreeParent(projectRoot) {
+    const marker = `${normalize('/.claude/worktrees/')}`;
+    const normalizedRoot = normalize(projectRoot);
+    const idx = normalizedRoot.indexOf(marker);
+    if (idx === -1)
+        return null;
+    return normalizedRoot.slice(0, idx) || null;
+}
+function listJsonlFiles(rootDir) {
+    if (!existsSync(rootDir)) {
+        return [];
+    }
+    const files = [];
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (entry.isFile() && (entry.name.endsWith('.jsonl') || entry.name.endsWith('.json'))) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files;
+}
+function uniqueSortedTargets(targets) {
+    const seen = new Set();
+    return targets
+        .filter((target) => {
+        const key = `${target.sourceType}:${target.filePath}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    })
+        .sort((a, b) => {
+        const aTime = existsSync(a.filePath) ? statSync(a.filePath).mtimeMs : 0;
+        const bTime = existsSync(b.filePath) ? statSync(b.filePath).mtimeMs : 0;
+        return bTime - aTime;
+    });
+}
+function buildCurrentProjectTargets(projectRoot) {
+    const claudeDir = getClaudeConfigDir();
+    const projectRoots = new Set([projectRoot]);
+    const mainRepoRoot = getMainRepoRoot(projectRoot);
+    if (mainRepoRoot)
+        projectRoots.add(mainRepoRoot);
+    const claudeWorktreeParent = getClaudeWorktreeParent(projectRoot);
+    if (claudeWorktreeParent)
+        projectRoots.add(claudeWorktreeParent);
+    const targets = [];
+    for (const root of projectRoots) {
+        const encodedDir = join(claudeDir, 'projects', encodeProjectPath(root));
+        for (const filePath of listJsonlFiles(encodedDir)) {
+            targets.push({ filePath, sourceType: 'project-transcript' });
+        }
+    }
+    const legacyTranscriptsDir = join(claudeDir, 'transcripts');
+    for (const filePath of listJsonlFiles(legacyTranscriptsDir)) {
+        targets.push({ filePath, sourceType: 'legacy-transcript' });
+    }
+    const omcRoot = getOmcRoot(projectRoot);
+    const sessionSummariesDir = join(omcRoot, 'sessions');
+    for (const filePath of listJsonlFiles(sessionSummariesDir)) {
+        targets.push({ filePath, sourceType: 'omc-session-summary' });
+    }
+    const replayDir = join(omcRoot, 'state');
+    if (existsSync(replayDir)) {
+        for (const filePath of listJsonlFiles(replayDir)) {
+            if (filePath.includes('agent-replay-') && filePath.endsWith('.jsonl')) {
+                targets.push({ filePath, sourceType: 'omc-session-replay' });
+            }
+        }
+    }
+    return uniqueSortedTargets(targets);
+}
+function buildAllProjectTargets() {
+    const claudeDir = getClaudeConfigDir();
+    const targets = [];
+    for (const filePath of listJsonlFiles(join(claudeDir, 'projects'))) {
+        targets.push({ filePath, sourceType: 'project-transcript' });
+    }
+    for (const filePath of listJsonlFiles(join(claudeDir, 'transcripts'))) {
+        targets.push({ filePath, sourceType: 'legacy-transcript' });
+    }
+    return uniqueSortedTargets(targets);
+}
+function isWithinProject(projectPath, projectRoots) {
+    if (!projectPath) {
+        return false;
+    }
+    const normalizedProjectPath = normalize(resolve(projectPath));
+    return projectRoots.some((root) => {
+        const normalizedRoot = normalize(resolve(root));
+        return normalizedProjectPath === normalizedRoot || normalizedProjectPath.startsWith(`${normalizedRoot}/`);
+    });
+}
+function matchesProjectFilter(projectPath, projectFilter) {
+    if (!projectFilter || projectFilter === 'all') {
+        return true;
+    }
+    if (!projectPath) {
+        return false;
+    }
+    return projectPath.toLowerCase().includes(projectFilter.toLowerCase());
+}
+function stringLeaves(value, maxLeaves = 24) {
+    const leaves = [];
+    const stack = [value];
+    while (stack.length > 0 && leaves.length < maxLeaves) {
+        const current = stack.pop();
+        if (typeof current === 'string') {
+            const compacted = compactWhitespace(current);
+            if (compacted.length > 0) {
+                leaves.push(compacted);
+            }
+            continue;
+        }
+        if (Array.isArray(current)) {
+            stack.push(...current);
+            continue;
+        }
+        if (current && typeof current === 'object') {
+            stack.push(...Object.values(current));
+        }
+    }
+    return leaves;
+}
+function extractTranscriptTexts(entry) {
+    const texts = [];
+    const message = entry.message;
+    const content = message?.content;
+    if (typeof content === 'string') {
+        texts.push(content);
+    }
+    else if (Array.isArray(content)) {
+        for (const block of content) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const record = block;
+            const blockType = typeof record.type === 'string' ? record.type : undefined;
+            if ((blockType === 'text' || blockType === 'thinking' || blockType === 'reasoning') && typeof record.text === 'string') {
+                texts.push(record.text);
+                continue;
+            }
+            if (blockType === 'tool_result') {
+                texts.push(...stringLeaves(record.content));
+                continue;
+            }
+            if (blockType === 'tool_use') {
+                const toolName = typeof record.name === 'string' ? record.name : 'tool';
+                const inputText = stringLeaves(record.input).join(' ');
+                if (inputText) {
+                    texts.push(`${toolName} ${inputText}`);
+                }
+            }
+        }
+    }
+    return texts;
+}
+function buildTranscriptEntry(entry) {
+    const texts = extractTranscriptTexts(entry);
+    if (texts.length === 0) {
+        return null;
+    }
+    const message = entry.message;
+    const sessionId = typeof entry.sessionId === 'string'
+        ? entry.sessionId
+        : typeof entry.session_id === 'string'
+            ? entry.session_id
+            : typeof message?.sessionId === 'string'
+                ? message.sessionId
+                : undefined;
+    if (!sessionId) {
+        return null;
+    }
+    return {
+        sessionId,
+        agentId: typeof entry.agentId === 'string' ? entry.agentId : undefined,
+        timestamp: typeof entry.timestamp === 'string' ? entry.timestamp : undefined,
+        projectPath: typeof entry.cwd === 'string' ? entry.cwd : undefined,
+        role: typeof message?.role === 'string' ? message.role : undefined,
+        entryType: typeof entry.type === 'string' ? entry.type : undefined,
+        texts,
+    };
+}
+function buildJsonArtifactEntry(entry, sourceType) {
+    const sessionId = typeof entry.session_id === 'string'
+        ? entry.session_id
+        : typeof entry.sessionId === 'string'
+            ? entry.sessionId
+            : undefined;
+    if (!sessionId) {
+        return null;
+    }
+    const texts = stringLeaves(entry);
+    if (texts.length === 0) {
+        return null;
+    }
+    const timestamp = typeof entry.ended_at === 'string'
+        ? entry.ended_at
+        : typeof entry.started_at === 'string'
+            ? entry.started_at
+            : typeof entry.timestamp === 'string'
+                ? entry.timestamp
+                : undefined;
+    const entryType = sourceType === 'omc-session-summary' ? 'session-summary' : 'session-replay';
+    return {
+        sessionId,
+        timestamp,
+        projectPath: typeof entry.cwd === 'string' ? entry.cwd : undefined,
+        entryType,
+        texts,
+    };
+}
+function buildSearchableEntry(entry, sourceType) {
+    if (sourceType === 'project-transcript' || sourceType === 'legacy-transcript' || sourceType === 'omc-session-replay') {
+        return buildTranscriptEntry(entry) ?? (sourceType === 'omc-session-replay' ? buildJsonArtifactEntry(entry, sourceType) : null);
+    }
+    if (sourceType === 'omc-session-summary') {
+        return buildJsonArtifactEntry(entry, sourceType);
+    }
+    return null;
+}
+function findMatchIndex(text, query, caseSensitive) {
+    const haystack = normalizeForSearch(text, caseSensitive);
+    const needle = normalizeForSearch(query, caseSensitive);
+    const directIndex = haystack.indexOf(needle);
+    if (directIndex >= 0) {
+        return directIndex;
+    }
+    const terms = needle.split(/\s+/).filter(Boolean);
+    if (terms.length === 0)
+        return -1;
+    if (terms.every((term) => haystack.includes(term))) {
+        return haystack.indexOf(terms[0]);
+    }
+    return -1;
+}
+function createExcerpt(text, matchIndex, contextChars) {
+    const compacted = compactWhitespace(text);
+    if (compacted.length <= contextChars * 2) {
+        return compacted;
+    }
+    const safeIndex = Math.max(0, matchIndex);
+    const start = Math.max(0, safeIndex - contextChars);
+    const end = Math.min(compacted.length, safeIndex + contextChars);
+    const prefix = start > 0 ? '…' : '';
+    const suffix = end < compacted.length ? '…' : '';
+    return `${prefix}${compacted.slice(start, end).trim()}${suffix}`;
+}
+function buildScopeMode(project) {
+    if (!project || project === 'current')
+        return 'current';
+    if (project === 'all')
+        return 'all';
+    return 'project';
+}
+async function collectMatchesFromFile(target, options) {
+    const matches = [];
+    const fileMtime = existsSync(target.filePath) ? statSync(target.filePath).mtimeMs : 0;
+    if (target.sourceType === 'omc-session-summary' && target.filePath.endsWith('.json')) {
+        try {
+            const payload = JSON.parse(await import('fs/promises').then((fs) => fs.readFile(target.filePath, 'utf-8')));
+            const entry = buildSearchableEntry(payload, target.sourceType);
+            if (!entry)
+                return [];
+            if (options.sessionId && entry.sessionId !== options.sessionId)
+                return [];
+            if (options.projectRoots && options.projectRoots.length > 0 && !isWithinProject(entry.projectPath, options.projectRoots))
+                return [];
+            if (!matchesProjectFilter(entry.projectPath, options.projectFilter))
+                return [];
+            const entryEpoch = entry.timestamp ? Date.parse(entry.timestamp) : fileMtime;
+            if (options.sinceEpoch && Number.isFinite(entryEpoch) && entryEpoch < options.sinceEpoch)
+                return [];
+            for (const text of entry.texts) {
+                const matchIndex = findMatchIndex(text, options.query, options.caseSensitive);
+                if (matchIndex < 0)
+                    continue;
+                matches.push({
+                    sessionId: entry.sessionId,
+                    timestamp: entry.timestamp,
+                    projectPath: entry.projectPath,
+                    sourcePath: target.filePath,
+                    sourceType: target.sourceType,
+                    line: 1,
+                    role: entry.role,
+                    entryType: entry.entryType,
+                    excerpt: createExcerpt(text, matchIndex, options.contextChars),
+                });
+                break;
+            }
+        }
+        catch {
+            return [];
+        }
+        return matches;
+    }
+    const stream = createReadStream(target.filePath, { encoding: 'utf-8' });
+    const reader = createInterface({ input: stream, crlfDelay: Infinity });
+    let line = 0;
+    try {
+        for await (const rawLine of reader) {
+            line += 1;
+            if (!rawLine.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(rawLine);
+            }
+            catch {
+                continue;
+            }
+            const entry = buildSearchableEntry(parsed, target.sourceType);
+            if (!entry)
+                continue;
+            if (options.sessionId && entry.sessionId !== options.sessionId)
+                continue;
+            if (options.projectRoots && options.projectRoots.length > 0 && !isWithinProject(entry.projectPath, options.projectRoots))
+                continue;
+            if (!matchesProjectFilter(entry.projectPath, options.projectFilter))
+                continue;
+            const entryEpoch = entry.timestamp ? Date.parse(entry.timestamp) : fileMtime;
+            if (options.sinceEpoch && Number.isFinite(entryEpoch) && entryEpoch < options.sinceEpoch)
+                continue;
+            for (const text of entry.texts) {
+                const matchIndex = findMatchIndex(text, options.query, options.caseSensitive);
+                if (matchIndex < 0)
+                    continue;
+                matches.push({
+                    sessionId: entry.sessionId,
+                    agentId: entry.agentId,
+                    timestamp: entry.timestamp,
+                    projectPath: entry.projectPath,
+                    sourcePath: target.filePath,
+                    sourceType: target.sourceType,
+                    line,
+                    role: entry.role,
+                    entryType: entry.entryType,
+                    excerpt: createExcerpt(text, matchIndex, options.contextChars),
+                });
+                break;
+            }
+        }
+    }
+    finally {
+        reader.close();
+        stream.destroy();
+    }
+    return matches;
+}
+export async function searchSessionHistory(rawOptions) {
+    const query = compactWhitespace(rawOptions.query || '');
+    if (!query) {
+        throw new Error('Query cannot be empty');
+    }
+    if (rawOptions.sessionId) {
+        validateSessionId(rawOptions.sessionId);
+    }
+    const limit = Math.max(1, rawOptions.limit ?? DEFAULT_LIMIT);
+    const contextChars = Math.max(20, rawOptions.contextChars ?? DEFAULT_CONTEXT_CHARS);
+    const caseSensitive = rawOptions.caseSensitive ?? false;
+    const sinceEpoch = parseSinceSpec(rawOptions.since);
+    const workingDirectory = validateWorkingDirectory(rawOptions.workingDirectory);
+    const currentProjectRoot = resolveToWorktreeRoot(workingDirectory);
+    const scopeMode = buildScopeMode(rawOptions.project);
+    const projectFilter = scopeMode === 'project' ? rawOptions.project : undefined;
+    const currentProjectRoots = [currentProjectRoot]
+        .concat(getMainRepoRoot(currentProjectRoot) ?? [])
+        .concat(getClaudeWorktreeParent(currentProjectRoot) ?? [])
+        .filter((value, index, arr) => Boolean(value) && arr.indexOf(value) === index);
+    const targets = scopeMode === 'all'
+        ? buildAllProjectTargets()
+        : buildCurrentProjectTargets(currentProjectRoot);
+    const allMatches = [];
+    for (const target of targets) {
+        const fileMatches = await collectMatchesFromFile(target, {
+            query,
+            caseSensitive,
+            contextChars,
+            sinceEpoch,
+            sessionId: rawOptions.sessionId,
+            projectFilter,
+            projectRoots: scopeMode === 'current' ? currentProjectRoots : undefined,
+        });
+        allMatches.push(...fileMatches);
+    }
+    allMatches.sort((a, b) => {
+        const aTime = a.timestamp ? Date.parse(a.timestamp) : 0;
+        const bTime = b.timestamp ? Date.parse(b.timestamp) : 0;
+        if (aTime !== bTime)
+            return bTime - aTime;
+        return a.sourcePath.localeCompare(b.sourcePath);
+    });
+    return {
+        query,
+        scope: {
+            mode: scopeMode,
+            project: rawOptions.project,
+            workingDirectory: currentProjectRoot,
+            since: rawOptions.since,
+            caseSensitive,
+        },
+        searchedFiles: targets.length,
+        totalMatches: allMatches.length,
+        results: allMatches.slice(0, limit),
+    };
+}
+export { parseSinceSpec };
+//# sourceMappingURL=index.js.map