codex/codex-rs/ext/memories/src/local/read.rs

use codex_utils_output_truncation::TruncationPolicy;
use codex_utils_output_truncation::truncate_text;

use crate::DEFAULT_READ_MAX_TOKENS;
use crate::backend::MemoriesBackendError;
use crate::backend::ReadMemoryRequest;
use crate::backend::ReadMemoryResponse;

use super::LocalMemoriesBackend;
use super::path::reject_symlink;

pub(super) async fn read(
    backend: &LocalMemoriesBackend,
    request: ReadMemoryRequest,
) -> Result<ReadMemoryResponse, MemoriesBackendError> {
    if request.line_offset == 0 {
        return Err(MemoriesBackendError::InvalidLineOffset);
    }
    if request.max_lines == Some(0) {
        return Err(MemoriesBackendError::InvalidMaxLines);
    }

    let path = backend
        .resolve_scoped_path(Some(request.path.as_str()))
        .await?;
    let Some(metadata) = LocalMemoriesBackend::metadata_or_none(&path).await? else {
        return Err(MemoriesBackendError::NotFound { path: request.path });
    };
    reject_symlink(&request.path, &metadata)?;
    if !metadata.is_file() {
        return Err(MemoriesBackendError::NotFile { path: request.path });
    }

    let original_content = tokio::fs::read_to_string(&path).await?;
    let start_byte = line_start_byte_offset(&original_content, request.line_offset)?;
    let end_byte = line_end_byte_offset(&original_content, start_byte, request.max_lines);
    let content_from_offset = &original_content[start_byte..end_byte];
    let max_tokens = if request.max_tokens == 0 {
        DEFAULT_READ_MAX_TOKENS
    } else {
        request.max_tokens
    };
    let content = truncate_text(content_from_offset, TruncationPolicy::Tokens(max_tokens));
    let truncated = end_byte < original_content.len() || content != content_from_offset;
    Ok(ReadMemoryResponse {
        path: request.path,
        start_line_number: request.line_offset,
        content,
        truncated,
    })
}

fn line_start_byte_offset(
    content: &str,
    line_offset: usize,
) -> Result<usize, MemoriesBackendError> {
    if line_offset == 1 {
        return Ok(0);
    }

    let mut current_line = 1;
    for (idx, ch) in content.char_indices() {
        if ch == '\n' {
            current_line += 1;
            if current_line == line_offset {
                return Ok(idx + 1);
            }
        }
    }

    Err(MemoriesBackendError::LineOffsetExceedsFileLength)
}

fn line_end_byte_offset(content: &str, start_byte: usize, max_lines: Option<usize>) -> usize {
    let Some(max_lines) = max_lines else {
        return content.len();
    };

    let mut lines_seen = 1;
    for (relative_idx, ch) in content[start_byte..].char_indices() {
        if ch == '\n' {
            if lines_seen == max_lines {
                return start_byte + relative_idx + 1;
            }
            lines_seen += 1;
        }
    }

    content.len()
}