excel-mcp-server 0.1.0

An MCP server that exposes Excel manipulation tools over stdio and streamable HTTP transports
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use super::common::workbook_not_found;
use crate::engines::zavora;
use crate::store::WorkbookStore;
use crate::types::inputs::*;
use crate::types::responses::*;

pub fn write_cells(
    store: &mut WorkbookStore,
    input: WriteCellsInput,
) -> Result<String, anyhow::Error> {
    let entry = match store.get_mut(&input.workbook_id) {
        Some(e) => e,
        None => return Ok(workbook_not_found(store, &input.workbook_id)),
    };
    let idx = match find_sheet(&entry.data, &input.sheet_name) {
        Some(i) => i,
        None => return Ok(sheet_not_found(&input.sheet_name)),
    };
    let ws = entry
        .data
        .worksheet(idx)
        .map_err(|e| anyhow::anyhow!("{e}"))?;
    let mut count = 0usize;
    for cw in &input.cells {
        let (row, col) = match zavora_xlsx::utility::parse_cell_ref(&cw.cell) {
            Ok(rc) => rc,
            Err(e) => {
                return Ok(error(
                    ErrorCategory::ParseError,
                    &format!("Invalid cell reference '{}': {e}", cw.cell),
                    "Use A1 notation.",
                ))
            }
        };
        if let Err(e) = zavora::write_json_value(ws, row, col, &cw.value) {
            return Ok(error(
                ErrorCategory::IoError,
                &format!("Write error: {e}"),
                "Check value type.",
            ));
        }
        count += 1;
    }
    Ok(success(
        "Cells written",
        WriteResult {
            cells_written: count,
            range_covered: format!("{} cells", count),
        },
    ))
}

pub fn write_row(store: &mut WorkbookStore, input: WriteRowInput) -> Result<String, anyhow::Error> {
    let entry = match store.get_mut(&input.workbook_id) {
        Some(e) => e,
        None => return Ok(workbook_not_found(store, &input.workbook_id)),
    };
    let idx = match find_sheet(&entry.data, &input.sheet_name) {
        Some(i) => i,
        None => return Ok(sheet_not_found(&input.sheet_name)),
    };
    let (row, start_col) = zavora_xlsx::utility::parse_cell_ref(&input.start_cell)
        .map_err(|e| anyhow::anyhow!("{e}"))?;
    let ws = entry
        .data
        .worksheet(idx)
        .map_err(|e| anyhow::anyhow!("{e}"))?;
    for (i, val) in input.values.iter().enumerate() {
        zavora::write_json_value(ws, row, start_col + i as u16, val)
            .map_err(|e| anyhow::anyhow!("{e}"))?;
    }
    let end = zavora_xlsx::utility::to_a1(row, start_col + input.values.len() as u16 - 1);
    Ok(success(
        "Row written",
        WriteResult {
            cells_written: input.values.len(),
            range_covered: format!("{}:{}", input.start_cell, end),
        },
    ))
}

pub fn write_column(
    store: &mut WorkbookStore,
    input: WriteColumnInput,
) -> Result<String, anyhow::Error> {
    let entry = match store.get_mut(&input.workbook_id) {
        Some(e) => e,
        None => return Ok(workbook_not_found(store, &input.workbook_id)),
    };
    let idx = match find_sheet(&entry.data, &input.sheet_name) {
        Some(i) => i,
        None => return Ok(sheet_not_found(&input.sheet_name)),
    };
    let (start_row, col) = zavora_xlsx::utility::parse_cell_ref(&input.start_cell)
        .map_err(|e| anyhow::anyhow!("{e}"))?;
    let ws = entry
        .data
        .worksheet(idx)
        .map_err(|e| anyhow::anyhow!("{e}"))?;
    for (i, val) in input.values.iter().enumerate() {
        zavora::write_json_value(ws, start_row + i as u32, col, val)
            .map_err(|e| anyhow::anyhow!("{e}"))?;
    }
    let end = zavora_xlsx::utility::to_a1(start_row + input.values.len() as u32 - 1, col);
    Ok(success(
        "Column written",
        WriteResult {
            cells_written: input.values.len(),
            range_covered: format!("{}:{}", input.start_cell, end),
        },
    ))
}

fn find_sheet(wb: &zavora_xlsx::Workbook, name: &str) -> Option<usize> {
    wb.sheet_names().iter().position(|n| *n == name)
}

fn sheet_not_found(name: &str) -> String {
    error(
        ErrorCategory::NotFound,
        &format!("Sheet '{}' not found", name),
        "Check sheet name.",
    )
}