XLIDE

Changes how a range looks: bold and font, fill colour, borders, alignment, number format, and merging. Only what you pass is changed, so each cell keeps the rest of its own format and making a header row bold does not flatten the number formats under it. Colours are RRGGBB or AARRGGBB hex without a leading hash. A number format is an Excel format code such as '#,##0.00' or 'yyyy-mm-dd'; that code is also what decides whether a number is shown as a date. Merging clears values and formulas outside the top-left cell; allow_overwrite is required when that would discard content. Works on .xlsx, .xl…

Lists what changed inside an Office file since a git revision, one entry per VBA module and Power Query, with a unified diff. git diff cannot show this: the file is binary, so a commit that changed one line and one that replaced the whole project look the same. Call this before committing, and to review what an agent or a colleague changed. Worksheet cell values are not compared. Defaults to HEAD; pass any revision git understands. Needs the file to be inside a git repository and tracked in that revision.

Reads .bas and .cls files from a folder back into an Office file's VBA project and saves it. Previews by default: it reports which modules would change and by how much, and writes nothing until apply=true. A file whose name matches no module creates one. Document modules such as ThisWorkbook are written but never created. Applying an unchanged plan skips the save. After a change, call xlide_analyze.

Says whether a file is open in its Office application, in any running instance: read-only or for editing, with unsaved changes or not, and which processes hold it locked. Call it when a write reports the file is locked, before closing anything, or when the user asks. Windows only. Changes nothing.

Lists the UserForms in an Office file, or the forms and reports in an Access database, with each one's control count and, for Access, the sections a control can go in. A design's code is a module of the same name, read with xlide_read_module. An unreadable report collection is a failure, not an empty list. An unreadable design's sections are marked unknown with sections_error. Use offset and next_offset to read large form lists in pages.

Lists the VBA modules in an Office file: name, kind (standard, class, document or userform), line count, and a content_token to pass to a guarded write. xlide_project_info returns this and more in one call; use this one when the file is already known and only the module list is wanted. Use offset and next_offset to read large projects in pages.

Lists the Sub, Function and Property procedures in one module, with each one's kind, scope, line number and signature. The module's content_token can guard an xlide_edit_module call. Use it to find where to change something without reading a long module in full. Use offset and next_offset to page through a module with many procedures.

Finds the Office files in this server's workspace and returns their absolute paths, host application and whether their VBA can be opened. Call this first when the user has not named a file. Covers Excel (.xlsm, .xlsb, .xlam, .xls, and .xlsx for Power Query and sheets), Word (.docm, .dotm, .doc), PowerPoint (.pptm, .potm), Access (.accdb, .mdb), and Visual Basic 6 projects (.vbp, whose modules are the files its manifest names). Files whose extension is recognized but not openable are listed with the reason, so a template or add-in is not silently missing. Use offset and next_offset to read larg…

Lists the Power Query queries in an Excel workbook: name, group, description, where each loads, and its applied step names. If the M formula cannot be parsed, steps is null with steps_error rather than an empty list. Queries live outside the VBA project, so a plain .xlsx has them too. Call this when asked what a workbook does; a workbook with no macros can still be doing most of its work here. Use offset and next_offset to read large query lists in pages.

Lists the type libraries a VBA project references: the name code uses to qualify them, the kind, and the registry or file path the project recorded. Call it when a name will not resolve, when deciding between early and late binding, or when code works on one machine and not another: a reference names a path and a version, so a project can be broken by the machine rather than by its own code.

Lists what sits on a worksheet's drawing layer: buttons, form controls, AutoShapes, text boxes, pictures, charts and groups, each with the cells it covers, its position in points and, where it has one, the macro a click runs. A form control also carries what it holds: a check box's state, a list's chosen item, a spinner's value and bounds, the cell it is linked to. Call it when asked how a workbook is started, or before renaming a Sub: a button's OnAction names a procedure and nothing rewrites it. ActiveX controls are listed but have no macro; their code is event procedures in the sheet's modu…

Lists the worksheets in an Excel file with their used ranges, whether each is hidden, and the pivot tables on each, the chart sheets, and the workbook's named ranges. Call this before reading cells, so the range you ask for is one that holds data. On .xlsx, .xlsm and .xlam the file also supplies pivot tables, chart sheets and named ranges. For .xlsb and .xls, Windows with Excel is required; that path surveys sheet names, used ranges and visibility only. Unreadable visibility or pivot metadata is marked unknown with hidden_error or pivot_tables_error. A malformed Excel survey is refused rather …

Reads a module's text as the running editor holds it, including edits the user has not saved. This is the one read that can differ from xlide_read_module, and the difference is exactly the user's unsaved work. Use it to see what they are actually working on; use xlide_read_module for what is in the file. surface_only=true reads the modern editor's own copy instead, which exists only for a module the user has open in a tab. start_line and end_line read a slice of long live source; content_token describes the whole live module.

Description is built at runtime.

Lists the running xlide_vbide sessions this machine can reach: one per Office process that has opened the Visual Basic Editor with the add-in loaded. Use it to find out whether the user has a live editor before asking about what is on their screen. Windows only, and the add-in's local API has to be switched on by the user. Each session is probed before it is listed, because a discovery file outlives the process that wrote it.

What the running Visual Basic Editor is doing right now: the module and project on screen, whether the project is in break mode, whether there are unsaved edits, the procedure the caret is in, and whether the analyzer engine is answering. Use it when the user asks about what they are looking at, or before suggesting an edit to a module they may have unsaved changes in.

Lists, writes, answers or removes the comments on a worksheet's cells. Excel has two kinds: a note, the yellow box that shows on hover, and a threaded comment, the conversation on the Review tab with replies and a resolved state. action='list' reads both and changes nothing. 'set' writes a note, replacing one already on the cell, or with kind='thread' starts a conversation; 'reply' and 'resolve' act on a thread; 'remove' takes either kind off the cell. Use a note to explain a cell to whoever reads the workbook next.

Lists, adds or clears conditional formatting: the rules that colour cells by what is in them. rule='cell_is' with an operator and a value paints cells that compare true; rule='expression' takes a formula written for the top-left cell of the range and applied relatively, the way Excel's 'Use a formula' box works; rule='color_scale' and 'data_bar' are the gradient and in-cell bar. The paint itself is the fill and font arguments, which is what Excel calls a differential format.

Lists, sets, reapplies or clears the autofilter on a worksheet or on an Excel table, and hides the rows it filters out. Excel does not apply a filter when it opens a workbook: it shows the rows as the file marks them, so the rows are worked out here, held to what Excel keeps. action='list' reads the filters and changes nothing. 'set' filters one column and keeps what the others already filter by; call it once per column. Give criteria as VBA's Range.AutoFilter spells Criteria1 and Criteria2: '>=10', '=North', '=*east*', '=' for blanks, '<>' for anything; or top for the top N items (negative fo…

Creates a UserForm, or an Access form or report, and saves the file. A form is a designer storage and a code module of the same name, and this writes both, which is why it exists rather than xlide_write_module. Renaming and deleting work on Access designs, where both halves move together; for a UserForm they are refused, because nothing here can move the designer storage and doing half of it loses the form. Add controls afterwards with xlide_edit_form, and write its event procedures with xlide_write_module.

Lists, adds or removes hyperlinks on a worksheet. A link either goes out to a target, which is a URL or a file path, or inside the workbook to a location such as 'Summary!A1'. Pass one or the other. The cell's displayed text is separate from the link and is left alone unless you pass display.

Lists, adds or removes a workbook's defined names. A defined name is what lets a formula say TaxRate rather than Config!$B$7, and VBA reads them too, so removing one can break code as well as formulas. action='list' changes nothing. For a range, qualify refers_to with its sheet and use absolute addresses to avoid following the active sheet or moving with a copied formula, for example Data!$A$1:$A$50.

Adds or removes a type library reference in a VBA project and saves the file. Use it when xlide_analyze reports missing-library-reference, or when code needs early binding, as Dim d As Scripting.Dictionary does. Name the library: Excel, Word, PowerPoint and Access work anywhere, and on Windows any library the VBA editor's References dialog lists resolves by its description (Microsoft Scripting Runtime) or by the name code writes (Scripting), taking its GUID, version and path from this machine's registry. A name that matches several libraries is refused with the candidates. Off Windows, pass gu…

Inserts, deletes, resizes, hides, shows, groups or ungroups whole rows or columns. Inserting and deleting move every reference in the workbook with them: a formula pointing below an inserted row follows it, and one pointing into deleted cells becomes #REF!, exactly as Excel does it. Deleting has no undo, so ask the user first. Widths are in characters and heights in points, which is what Excel's own dialogs use. Works on .xlsx, .xlsm and .xlam.

Adds a Forms control, an AutoShape, a text box, a line or a picture to a worksheet, or removes one, and saves the workbook. The usual case is a button that runs a macro: kind='button', a caption in text, and the procedure in macro as Proc or Module.Proc, written first. Place it with cell, its top-left cell, or with left and top in points; width and height are points, with a size to start from when left at 0. Check boxes, option buttons, lists and drop-downs take linked_cell, and lists and drop-downs list_range. A Forms control lives in four parts that have to agree, and they are written and re…

Adds, removes, renames, moves, hides, shows, protects or unprotects a worksheet. Renaming rewrites the formulas and defined names that referred to the old name, so nothing breaks. Removing a sheet takes its cells, tables and everything on it, and formulas elsewhere that pointed at it become #REF!, which has no undo: ask the user first. Protecting a sheet stops editing in Excel; it is not a security boundary and the password is trivially recovered. Works on .xlsx, .xlsm, .xlam.

Lists, adds or removes Excel tables, the ListObjects that Ctrl+T creates. A table names a block so formulas can say Sales[Amount] instead of an address that breaks when rows move, and it is what a Power Query load writes into. action='list' reads them and changes nothing. Adding one takes the column names from the header row of the range you give. Removing one leaves the cells and takes the table, so structured references to it break.

Lists, adds or clears data validation: what a cell will accept, and the dropdown it shows. kind='list' with formula1 as a comma-separated set of values gives a dropdown; kind='list' with a range reference gives one driven by cells. The other kinds take an operator and one or two formulas, which may be literals or references. Validation stops typing in Excel, not writing through this server, and Excel does not re-check cells that already held a value.

Opens a file in its Office application on the user's screen, for them to see or work in: after a change they should look at, or to put back a copy xlide_close_in_app closed. Already open, it is brought forward instead. read_only opens a copy that cannot be saved over the file, and new_instance a separate Excel or Word the user's other files are not in. bring_to_front=false reopens it behind whatever the user is doing. Macros follow the user's Trust Center settings, as for a file they open themselves. Windows only.

Reads how a worksheet is set up to print: orientation, paper size, margins, the print area, the rows or columns repeated on every page, whether it is scaled to fit, and the header and footer. Call it when asked why a sheet prints the way it does, or before changing a layout somebody set up deliberately.

A summary of one Office file in a single call: its VBA modules with kinds and line counts, its UserForms, its Power Query queries, its worksheets with used ranges and named ranges, and whether the VBA project is password-protected or digitally signed. has_vba_project is false for a macro-enabled file saved before its first macro, which is normal: the first xlide_write_module gives it a project. Call this once per file before working on it. Each module carries a content_token for a guarded write. For .xlsb and .xls sheet details, call xlide_list_sheets on Windows with Excel. An unreadable form …

Reads the SQL of one saved query in an Access database. Use it after xlide_access_catalog when a query's SQL was previewed. offset and max_chars read long SQL in character slices; next_offset points to the next slice. content_token describes the whole SQL, so compare it across pages if the database may have changed. Access files only.

Reads a range of cells from a worksheet and returns a grid of values, formulas, both, or the text each cell shows under its number format. On .xlsx, .xlsm and .xlam, values are what Excel last calculated and stored; calculate=true works formulas out in memory with pyOfficeEditor's engine and names cells it could not work out. A failed formatted or rich-text read names the cell and refuses rather than returning an empty value. On .xlsb and .xls, Windows with Excel is required and only calculated values are available, not formulas or formatted text. A partial grid from Excel is refused. At most …

Reads one form's design: every control with its name, type, the container it sits in, and the properties the developer set. Properties left at their default are not stored and so are not listed. A property read failure appears as _read_error, not an empty property set; unreadable sections have sections_error. Use offset and next_offset to read large forms in pages. Use it to understand a form's layout, or to see which control an event procedure belongs to.

The canonical way to read VBA. Returns a module's source as the VBA editor shows it, with the attribute header stripped, plus a content_token. Pass that token back as expected_content_token when you write, and the write is refused if anything changed the module in between. start_line and end_line read a slice of a long module; both are 1-based and inclusive. line_ranges reads several slices in one call, with each pair [first, last] using body line numbers.

Reads one query's M formula, with its description, group, load target and refresh settings. The formula is the let ... in expression as the Advanced Editor shows it. start_line and end_line read a slice of a long formula; the content_token always describes the whole query. If applied steps cannot be read, steps is null and steps_error gives the reason; the M formula remains available.

Removes later rows with the same values in the chosen columns, keeping the first row of each set, and saves the workbook. A range inside a table acts on the table and shrinks it. An empty columns list compares every column. This deletes data and cannot be undone in the file: ask the user before calling it. Works on .xlsx, .xlsm and .xlam.

Renames a VBA module everywhere its name is stored, and saves the file. Calls to the module's procedures elsewhere in the project are not rewritten; search for the old name first with xlide_search_modules. Document modules such as ThisWorkbook and Sheet1 cannot be renamed, because the host owns them.

The analyzer's rule catalogue: every diagnostic code with its title, default severity, category, whether it mirrors a VBA compile failure, and the MS-VBAL section it enforces. Use it to explain a code to the user, or to decide whether a finding is a compile error or a judgement call.

Runs a procedure that already exists in an Office file, in an application this server starts and owns, under a deadline. Windows only, with the application installed. The document opens read-only unless read_only=false, and closes without saving unless save=true. Returns the procedure's return value, anything it logged, and, on a VBA error, the error number and message. The failing line and call stack come from instrumentation applied to injected source, so a procedure already in the document does not carry them; run the same code through xlide_run_vba when you need them. A run that exceeds it…

Runs the VBA tests in an Office file: every zero-argument procedure whose name starts with Test. Windows only, with the application installed. Each test is run on its own, so one that hangs is reported as a timeout and the rest still run. Returns pass or fail per test with the assertion message, failing line, call stack and any logged output. Use PyVbaAssert and PyVbaAssertEqual in the tests; the harness supplies them.

Injects VBA source into a document and calls one procedure from it, under a deadline. Windows only. Use it to check what a piece of code actually does before writing it into a file, or to read something out of a document that no existing macro exposes. With no file_path it runs in a new empty document. Errors come back as data with the failing line and call stack, never as a dialog. Call PyVbaLog "text" from the code to return output; Debug.Print and MsgBox do not work under automation.

Searches every module's source in an Office file and returns each match with its module, line number and the line itself. Use it to find where a name is declared or used before changing it. content_tokens maps returned module names to tokens for guarded xlide_edit_module calls without a separate read. Use offset and next_offset to page through broad searches; total_match_count counts all matches. Plain text by default; set is_regex for a Python regular expression.

Changes which macro an existing shape or button runs when clicked, and saves the workbook. An empty macro clears the link. Use it after writing a Sub, so a button actually calls it, and after renaming one, because nothing rewrites an OnAction. Give the procedure as Proc or Module.Proc; it must already exist in the project, so write it first. To add a button with its macro, or to remove one, use xlide_manage_shape.

Sorts a range, a table's data rows, or a sheet autofilter's data rows, and saves the workbook. Keys are evaluated in order; each names a column letter for a range or filter, or a header name for a table. A range can keep its first row as a header. Hidden rows keep their places. Formulas, formatting, notes and links move with their rows. This changes existing data order and has no undo in the file: ask the user before calling it. Works on .xlsx, .xlsm and .xlam.

Moves, resizes, renames or changes an existing shape's text, alt text or visibility without replacing it. A Forms control can also change its linked cell or list range. Coordinates and sizes are in points; omit any field to leave it unchanged, and pass an empty text or link to clear it. ActiveX, embedded objects and groups cannot be updated. Works on .xlsx, .xlsm and .xlam.

Checks a file's VBA project for structural problems: records that disagree with each other, a module the directory names but the container does not hold, and the like. This is about the container, not about the code; use xlide_analyze for the code. Worth calling before risky work on an old or repaired file. Use offset and next_offset to read later problems from a damaged file.

Writes a rectangular block of values and formulas into a worksheet, starting at one cell, and saves the file. Each row of data is a row of the sheet. A string starting with '=' is written as a formula, as you would type it into Excel 365 with no _xlfn prefixes; anything else is a value. A cell given as {"rich_text": [{"text": "Total ", "bold": true}, {"text": "42"}]} is text in more than one font. A value written over a formula removes that formula, which is what typing into the cell does. On .xlsx, .xlsm and .xlam, only the touched worksheet rows are rewritten; their cached formula results re…

The canonical way to change VBA. Writes a module's source into the Office file and saves it. It replaces the module's whole source, so send all of it; send the body only, because the attribute header is managed for you. A module that does not exist is created: standard by default, or a class with kind='class'. Pass expected_content_token from your read and the write is refused if the module changed since. The result carries a diff of what the file now holds, read back after saving, which is what to show the user when they ask what changed. After writing, call xlide_analyze and treat any error …

Changes a workbook's Power Query and saves it. action='set' replaces a query's M formula, creating it if it does not exist; 'rename' renames it and rewrites the queries that reference it by name; 'remove' deletes it and everything that loaded it onto a sheet, which has no undo, so ask the user first. 'load' puts a query's result on a worksheet and 'unload' takes it back off. Loading needs the column names, because writing the connection means naming the columns and knowing them means running the query, which nothing here does; Excel settles them against the real result on the first refresh. A …