ask-marcel-office-cli 1.0.0 → 1.5.0

package/dist/use-cases/commands/download-drive-item-version.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+    versionId: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<{
+        markdown: "markdown";
+        pdf: "pdf";
+        original: "original";
+    }>>;
+    includeMetadata: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/{download-drive-item-version-as-markdown.d.ts → extract-drive-item-images.d.ts}

@@ -5,7 +5,6 @@ import type { CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     driveId: z.ZodString;
     itemId: z.ZodString;
-    versionId: z.ZodString;
 }, z.core.$strip>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;

package/dist/use-cases/commands/extract-local-file-images.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { FileSystem } from '../ports/filesystem.js';
+import type { CommandMeta } from './command-types.js';
+/**
+ * Extract embedded images from a file ON DISK — the local sibling of
+ * `extract-drive-item-images`, sharing its `extractImagesFromBytes` dispatch
+ * (OOXML media parts / unpdf page walk). It completes two flows the drive
+ * command cannot reach: a Graph-rendered PDF saved with the global
+ * output-path flag (the legacy-.ppt route), and Office files unpacked from a
+ * local archive. Like `convert-local-file`, it never touches Graph and is
+ * executed via `executeLocal(fs, params)`.
+ */
+declare const schema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+declare const executeLocal: (fs: FileSystem, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const execute: (_graph: GraphClient, _params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, executeLocal, meta, schema };

package/dist/use-cases/commands/{download-drive-item-version-content.d.ts → extract-mail-attachment-images.d.ts}

@@ -3,9 +3,8 @@ import type { Result } from '../../domain/result.js';
 import type { GraphClient, GraphError } from '../../infra/graph-client.js';
 import type { CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
-    driveId: z.ZodString;
-    itemId: z.ZodString;
-    versionId: z.ZodString;
+    messageId: z.ZodString;
+    attachmentId: z.ZodString;
 }, z.core.$strip>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;

package/dist/use-cases/commands/extract-sharepoint-links-in-documents.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+import type { ResolvedLink } from './sharepoint-link-extractor.js';
+/**
+ * The document-side sibling of `extract-sharepoint-links-in-mail`: pulls a
+ * docx/xlsx/pptx from a OneDrive / SharePoint item and finds every
+ * `*.sharepoint.com` URL embedded in it, resolving each to its driveItem so an
+ * agent can follow references out of a document the same way it follows them
+ * out of an email. Read-only — no conversion happens here.
+ *
+ * In OOXML, external hyperlinks live in the `_rels/*.rels` parts as
+ * `<Relationship Target="…" TargetMode="External"/>`. `extractExternalRels`
+ * (shared with the metadata extractors) already surfaces exactly those, so this
+ * command is pure composition: fetch bytes → open the package → collect external
+ * targets → keep the SharePoint ones → resolve via `/shares/{token}/driveItem`.
+ */
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+}, z.core.$strip>;
+type DocumentLinkSummary = {
+    readonly driveId: string;
+    readonly itemId: string;
+    readonly links: ReadonlyArray<ResolvedLink>;
+    readonly truncated: boolean;
+    readonly skippedCount: number;
+};
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<DocumentLinkSummary, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };
+export type { DocumentLinkSummary };

package/dist/use-cases/commands/extract-sharepoint-links-in-mail.d.ts

@@ -2,14 +2,7 @@ import { z } from 'zod';
 import type { Result } from '../../domain/result.js';
 import type { GraphClient, GraphError } from '../../infra/graph-client.js';
 import type { CommandMeta } from './command-types.js';
-type ResolvedLink = {
-    readonly url: string;
-    readonly driveId?: string;
-    readonly itemId?: string;
-    readonly name?: string;
-    readonly webUrl?: string;
-    readonly error?: string;
-};
+import type { ResolvedLink } from './sharepoint-link-extractor.js';
 type LinkExtractionSummary = {
     readonly messageId: string;
     readonly subject?: string;

package/dist/use-cases/commands/fetch-raw-bytes.d.ts

@@ -34,6 +34,7 @@ export type InlineBinary = {
     readonly size: number;
     readonly base64: string;
 };
+export declare const base64ToBytes: (b64: string) => Uint8Array;
 export declare const fetchRawBytes: (graph: GraphClient, contentPath: string, opts?: FetchOptions) => Promise<Result<Uint8Array, GraphError>>;
 export declare const inlineBinary: (graph: GraphClient, contentPath: string, opts?: FetchOptions) => Promise<Result<InlineBinary, GraphError>>;
 /**
@@ -44,7 +45,7 @@ export declare const inlineBinary: (graph: GraphClient, contentPath: string, opt
  * reference-attachment edge cases) Graph silently falls back to returning
  * the raw source bytes — same envelope shape, but contentType is the
  * source MIME (or `application/octet-stream`). The audit (round-5 #2)
- * caught this happening on `download-drive-item-version-as-pdf` for v79
+ * caught this happening on `download-drive-item-version --format pdf` for v79
  * of a pptx: the response said `contentType: "application/octet-stream"`
  * with the exact source byte size, and an LLM that saved it as `.pdf`
  * would have had a corrupt file.

package/dist/use-cases/commands/file-counts.d.ts

@@ -0,0 +1,7 @@
+import type { GraphClient } from '../../infra/graph-client.js';
+type FileCountOptions = {
+    readonly max?: number;
+    readonly chunk?: number;
+};
+declare const addEstimatedFileCounts: (graph: GraphClient, entries: ReadonlyArray<unknown>, webUrlOf: (entry: unknown) => string | undefined, options?: FileCountOptions) => Promise<ReadonlyArray<unknown>>;
+export { addEstimatedFileCounts };

package/dist/use-cases/commands/filter-archived-sites.d.ts

@@ -0,0 +1,17 @@
+import type { GraphClient } from '../../infra/graph-client.js';
+declare const ARCHIVE_PROBE_MAX = 250;
+type FilterOptions = {
+    readonly probeMax?: number;
+    readonly chunkSize?: number;
+};
+type FilterResult = {
+    readonly value: ReadonlyArray<unknown>;
+    readonly archivedExcluded: number;
+    readonly nonNavigableExcluded: number;
+    readonly notFoundExcluded: number;
+    readonly probeErrors: number;
+    readonly probeTruncated: boolean;
+};
+declare const filterOutArchivedSites: (graph: GraphClient, sites: ReadonlyArray<unknown>, options?: FilterOptions) => Promise<FilterResult>;
+export { ARCHIVE_PROBE_MAX, filterOutArchivedSites };
+export type { FilterResult };

package/dist/use-cases/commands/find-chats-with-user.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    name: z.ZodString;
+    maxPages: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/first-sentence.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Compact a multi-sentence summary to its first sentence — everything up to the
+ * first `. ` (period-space) or the first newline, whichever comes first. Returns
+ * the full text untouched when no sensible cut-point exists, so the result is
+ * never less readable than the original. Keeps the trailing period when cutting
+ * on `. ` so the line ends naturally.
+ *
+ * Shared by the top-level `--help` subcommand listing (composition) and the
+ * `help-json --terse` discovery projection (use-cases) so both compact the same
+ * way — the terse manifest in particular must stay token-cheap per category.
+ */
+export declare const firstSentence: (full: string) => string;

package/dist/use-cases/commands/get-chat.d.ts

@@ -1,8 +1,4 @@
-import { z } from 'zod';
 import type { CommandMeta } from './command-types.js';
-declare const schema: z.ZodObject<{
-    chatId: z.ZodString;
-}, z.core.$strip>;
-declare const execute: import("./command-types.js").CommandExecute;
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/get-excel-chart-image.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+/**
+ * Renders an Excel chart to a PNG via Graph's chart `Image()` function. Unlike
+ * the rest of the conversion surface, this endpoint returns the bytes as a
+ * base64 string in the JSON `value` field (NOT a 302 redirect), so a plain
+ * `graph.get` is enough. `width=0,height=0` = the chart's natural size;
+ * `fittingMode='Fit'` preserves aspect ratio.
+ */
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+    worksheetId: z.ZodString;
+    chartId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-excel-used-range.d.ts

@@ -1,10 +1,15 @@
 import { z } from 'zod';
-import type { CommandMeta } from './command-types.js';
+import type { Command, CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     driveId: z.ZodString;
     itemId: z.ZodString;
     worksheetId: z.ZodString;
+    full: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    maxCells: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const execute: (graph: import("../../index.js").GraphClient, params: Record<string, string>) => Promise<import("../../index.js").Result<unknown, import("../../index.js").GraphError>>;
+declare const execute: Command['execute'];
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/get-onenote-page-as-markdown.d.ts

@@ -4,6 +4,14 @@ import type { GraphClient, GraphError } from '../../infra/graph-client.js';
 import type { CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     onenotePageId: z.ZodString;
+    inlineImages: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    includeMetadata: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
 }, z.core.$strip>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;

package/dist/use-cases/commands/get-teams-chat-message.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-todo-task.d.ts

@@ -1,4 +1,11 @@
-import type { CommandMeta } from './command-types.js';
-declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    todoTaskListId: z.ZodString;
+    todoTaskId: z.ZodString;
+    select: z.ZodOptional<z.ZodString>;
+    expand: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/image-extraction.d.ts

@@ -0,0 +1,10 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+/**
+ * Shared by extract-drive-item-images and extract-mail-attachment-images: pick the
+ * extractor for the file's extension and run it, or return a 415 whose tail
+ * (`fetchHint`) names the caller's raw-bytes route. Both commands fetch / decode the
+ * bytes first, then hand them here, so the dispatch + media envelope live in one place.
+ */
+declare const extractImagesFromBytes: (bytes: Uint8Array, name: string, fetchHint: string) => Promise<Result<unknown, GraphError>>;
+export { extractImagesFromBytes };

package/dist/use-cases/commands/iso-datetime-schema.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+/**
+ * Reusable Zod field for an ISO-8601 UTC datetime parameter that ALSO accepts
+ * the relative-date vocabulary defined in `src/domain/iso-datetime.ts`
+ * (`7d`, `1w`, `today`, `monday`, `start-of-month`, etc.). Calendar commands
+ * compose this into their schemas in place of `z.string().min(1)`; the
+ * URL-builder sees the already-resolved canonical ISO form.
+ *
+ * Audit Jane-session §C: removes the manual ISO arithmetic an LLM had to do
+ * to ask "what changed this week" against `list-calendar-view`. Type
+ * inference is left to Zod so the calendar commands' shape signatures stay
+ * compatible with `buildListCommand`'s `ZodRawShape` constraint.
+ */
+export declare const isoDateTimeField: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../domain/iso-datetime.js").IsoDateTime, string>>;
+/**
+ * Standard `--start-date-time` / `--end-date-time` description used by every
+ * calendar-view command. Mentions both the strict ISO form Graph expects and
+ * the relative vocabulary the CLI also accepts, so the LLM sees both options
+ * in `--help`.
+ */
+export declare const RELATIVE_DATE_DESCRIPTION = "ISO 8601 UTC (e.g. `2026-04-01T00:00:00Z` or `2026-04-01`) OR a relative shape: `7d` / `1w` / `2h` / `30m` (past), `+7d` (future), `today` / `yesterday` / `tomorrow` / `now`, `monday`-`sunday` (most recent), `last-<weekday>` / `next-<weekday>`, `start-of-week|month|year`, `end-of-week|month|year`. Relative forms resolve at request time relative to the CLI process clock (UTC).";

package/dist/use-cases/commands/link-shape.d.ts

@@ -0,0 +1,13 @@
+type SiblingResolver = 'mail' | 'calendar' | 'teams' | 'drive-share';
+/**
+ * Classify a Zod-validated URL string by which sibling resolver it
+ * belongs to. Returns `null` when the URL matches none of the known
+ * resolver families (caller falls through to its own "unknown URL"
+ * rejection message).
+ *
+ * Precondition: `raw` has been validated through `z.url()`. Calling
+ * with an unvalidated string is a programmer error — `new URL(raw)`
+ * will throw and the atelier rule forbids try/catch outside infra.
+ */
+export declare const detectSiblingResolver: (raw: string) => SiblingResolver | null;
+export type { SiblingResolver };

package/dist/use-cases/commands/list-accessible-drives.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    maxGroups: z.ZodOptional<z.ZodString>;
+    countFiles: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/list-calendar-event-attachments.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    eventId: z.ZodString;
+    top: z.ZodOptional<z.ZodString>;
+    skip: z.ZodOptional<z.ZodString>;
+    select: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodString>;
+    orderby: z.ZodOptional<z.ZodString>;
+    expand: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/list-calendar-view-delta.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import type { Command, CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
-    startDateTime: z.ZodString;
-    endDateTime: z.ZodString;
+    startDateTime: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../domain/iso-datetime.js").IsoDateTime, string>>;
+    endDateTime: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../domain/iso-datetime.js").IsoDateTime, string>>;
     top: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const execute: Command['execute'];

package/dist/use-cases/commands/list-teams-chat-history.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    chatId: z.ZodString;
+    syncState: z.ZodOptional<z.ZodURL>;
+    pageSize: z.ZodOptional<z.ZodString>;
+    maxPages: z.ZodOptional<z.ZodString>;
+    full: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    maxContentChars: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/list-teams-chat-messages.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    chatId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/list-teams-chats-with-messages.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodString>;
+    continuationToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/mail-quote-stripper.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strips quoted reply chains / forwarded-message blocks from an Outlook or
+ * Gmail HTML email body so long threads don't duplicate quoted content into the
+ * model's context. Conservative: truncates the body at the EARLIEST well-known
+ * reply/forward boundary marker and replaces the tail with a single visible
+ * placeholder — nothing is removed silently, and `--keep-quoted true` on
+ * `convert-mail-to-markdown` restores the full body. Pure string transform.
+ *
+ * Only structural, vendor-specific markers are matched (never a bare
+ * `<blockquote>`, which legitimate content uses too):
+ *   - Outlook desktop / OWA reply+forward header block: `<div id="divRplyFwdMsg">`
+ *   - Outlook "type above this line" boundary:           `<div id="appendonsend">`
+ *   - Outlook mobile reference container:                `<div id="mail-editor-reference-message-container">`
+ *   - Outlook classic separator:                         `<hr id="stopSpelling">`
+ *   - Gmail quote container:                             `<div class="gmail_quote">` / `<blockquote class="gmail_quote">`
+ */
+declare const stripQuotedReplies: (html: string) => {
+    readonly html: string;
+    readonly stripped: boolean;
+};
+declare const stripQuotedPlainText: (text: string) => {
+    readonly text: string;
+    readonly stripped: boolean;
+};
+export { stripQuotedPlainText, stripQuotedReplies };

package/dist/use-cases/commands/markdown-dispatch.d.ts

@@ -0,0 +1,29 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+declare const IMAGE_EXTENSIONS: ReadonlySet<string>;
+type ConversionHints = {
+    readonly pdfNoText: string;
+    readonly legacyPpt: string;
+    readonly image: (ext: string) => string;
+    readonly generic: (ext: string) => string;
+};
+type BytesToMarkdownOptions = {
+    readonly includeMetadata?: boolean;
+    readonly maxCells?: number;
+    readonly inlineImages?: boolean;
+    readonly depth?: number;
+};
+declare const NESTED_HINTS: ConversionHints;
+/**
+ * The single extension→converter dispatch for every markdown command, operating on
+ * bytes already in hand: download-drive-item-as-markdown fetches them, convert-mail
+ * decodes the attachment, convert-drive-item-zip unpacks the entry. Loop/Fluid/
+ * Whiteboard (`?format=html`) need a Graph round-trip and are handled by the drive
+ * caller BEFORE this — they never reach here. An Outlook `.msg` is rendered to markdown
+ * (headers + body) with each of its own attachments recursed through this dispatch.
+ * `hints` carry the caller-specific messages; a non-text result is an `err` the caller
+ * surfaces (a 415, or a zip note).
+ */
+declare const bytesToMarkdown: (bytes: Uint8Array, filename: string, opts: BytesToMarkdownOptions, hints: ConversionHints) => Promise<Result<unknown, GraphError>>;
+export { bytesToMarkdown, IMAGE_EXTENSIONS, NESTED_HINTS };
+export type { BytesToMarkdownOptions, ConversionHints };

package/dist/use-cases/commands/markdown-pipeline.d.ts

@@ -18,6 +18,10 @@ type MarkdownEnvelope = {
     readonly size: number;
     readonly text: string;
 };
-declare const convertToMarkdown: (graph: GraphClient, contentPath: string, inlineAttachments?: ReadonlyArray<InlineAttachment>) => Promise<Result<MarkdownEnvelope, GraphError>>;
+type ConvertOptions = {
+    readonly inlineAttachments?: ReadonlyArray<InlineAttachment>;
+    readonly htmlTransform?: (html: string) => Promise<string>;
+};
+declare const convertToMarkdown: (graph: GraphClient, contentPath: string, options?: ConvertOptions) => Promise<Result<MarkdownEnvelope, GraphError>>;
 export { convertToMarkdown };
-export type { MarkdownEnvelope };
+export type { ConvertOptions, MarkdownEnvelope };

package/dist/use-cases/commands/media-files.d.ts

@@ -0,0 +1,20 @@
+import type { MediaPart } from '../../infra/ooxml-media-extractor.js';
+/**
+ * Shapes the raw media parts from the extractor into the inline response
+ * envelope `{ count, media: [{ path, contentType, sizeBytes, base64 }] }`.
+ * The global `--output-dir` flag recognises this shape and writes each image
+ * to disk (see `persistMediaIfRequested`); without it, the base64 rides back
+ * in the envelope. Shared by every image-extraction command.
+ */
+type MediaEnvelope = {
+    readonly count: number;
+    readonly media: ReadonlyArray<{
+        readonly path: string;
+        readonly contentType: string;
+        readonly sizeBytes: number;
+        readonly base64: string;
+    }>;
+};
+declare const buildMediaResponse: (parts: ReadonlyArray<MediaPart>) => MediaEnvelope;
+export { buildMediaResponse };
+export type { MediaEnvelope };

package/dist/use-cases/commands/msg-to-markdown.d.ts

@@ -0,0 +1,28 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+import type { ParsedMsg } from '../../infra/msg-reader-adapter.js';
+/**
+ * Render an Outlook `.msg` file to markdown: an H1 subject, a From/To/Cc/Bcc/Date
+ * header block, the message body (the plain-text body when present, else the HTML
+ * body run through turndown), and an `## Attachments` section where each attachment
+ * is converted recursively through the SAME dispatch the zip command uses — so a
+ * `.docx`/`.pdf`/`.csv` attached to an email becomes markdown inline, exactly as the
+ * user asked ("maybe same way as zip"). Unconvertible attachments (images, binaries)
+ * are listed with the dispatch's note instead of failing the whole message.
+ *
+ * `recurse` is the attachment converter injected by `markdown-dispatch` (its own
+ * `bytesToMarkdown`, with the recursion depth incremented). Injecting it — rather
+ * than importing `bytesToMarkdown` here — keeps this use-case off the dispatch's
+ * import cycle and lets every rendering branch be tested with a plain fake. `depth`
+ * caps `.msg`-inside-`.msg` nesting: past {@link MAX_MSG_DEPTH} levels an embedded
+ * message's attachments are listed but not expanded.
+ */
+declare const MAX_MSG_DEPTH = 3;
+type MsgToMarkdownOptions = {
+    readonly depth?: number;
+};
+type MsgAttachmentConverter = (bytes: Uint8Array, filename: string) => Promise<Result<unknown, GraphError>>;
+declare const renderMsg: (msg: ParsedMsg, depth: number, recurse: MsgAttachmentConverter) => Promise<string>;
+declare const msgToMarkdown: (bytes: Uint8Array, opts: MsgToMarkdownOptions, recurse: MsgAttachmentConverter) => Promise<Result<unknown, GraphError>>;
+export { MAX_MSG_DEPTH, msgToMarkdown, renderMsg };
+export type { MsgAttachmentConverter, MsgToMarkdownOptions };

package/dist/use-cases/commands/odf-content-to-markdown.d.ts

@@ -0,0 +1,5 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+declare const renderOdfContent: (xml: string | undefined) => string;
+declare const odfContentToMarkdown: (bytes: Uint8Array) => Promise<Result<string, GraphError>>;
+export { odfContentToMarkdown, renderOdfContent };

package/dist/use-cases/commands/odf-metadata-to-markdown.d.ts

@@ -0,0 +1,3 @@
+import type { OdfMetadata } from './odf-metadata.js';
+declare const formatOdfMetadata: (meta: OdfMetadata) => string;
+export { formatOdfMetadata };

package/dist/use-cases/commands/odf-metadata.d.ts

@@ -0,0 +1,26 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+/**
+ * Pulls the side-channel content out of an OpenDocument package (.odt / .ods /
+ * .odp and their .ot* template variants). OpenDocument is also a ZIP, so the
+ * shared `openOoxmlZip` adapter + XML walker apply directly; only the metadata
+ * shape differs — it lives in a single `meta.xml` (`office:document-meta >
+ * office:meta`) rather than the OOXML `docProps/*` parts.
+ *
+ * High-value subset: document properties (Dublin Core + ODF meta fields like
+ * generator / editing-cycles / creation-date), keyword list, and user-defined
+ * custom properties (`meta:user-defined`) — the ODF analog of OOXML custom
+ * document properties.
+ */
+type UserDefined = {
+    readonly name: string;
+    readonly value: string;
+};
+type OdfMetadata = {
+    readonly properties: Readonly<Record<string, string>>;
+    readonly keywords: ReadonlyArray<string>;
+    readonly userDefined: ReadonlyArray<UserDefined>;
+};
+declare const extractOdfMetadata: (bytes: Uint8Array) => Promise<Result<OdfMetadata, GraphError>>;
+export { extractOdfMetadata };
+export type { OdfMetadata, UserDefined };

package/dist/use-cases/commands/odf-to-markdown.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+import type { MarkdownEnvelope } from './docx-to-markdown.js';
+/**
+ * Converts an OpenDocument (.odt / .ods / .odp) body to markdown by walking
+ * `content.xml` (headings / paragraphs / lists / tables for text docs, named
+ * sheet-tables for spreadsheets, per-slide text for presentations — including
+ * style-hidden content a rendered viewer would suppress). With
+ * `--include-metadata true` the side-channel / authored metadata
+ * (properties, keywords, user-defined fields) is appended as a trailing block.
+ */
+type OdfToMarkdownOptions = {
+    readonly includeMetadata?: boolean;
+};
+declare const odfToMarkdown: (bytes: Uint8Array, opts?: OdfToMarkdownOptions) => Promise<Result<MarkdownEnvelope, GraphError>>;
+export { odfToMarkdown };
+export type { OdfToMarkdownOptions };

package/dist/use-cases/commands/office-extensions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Single source of truth for the OOXML extension families the markdown
+ * dispatchers route together. Each family shares one parser/extractor: the
+ * macro-enabled (`*m`) and template (`*tx` / `*tm`) variants are structurally
+ * identical to their base format, so they alias onto the same path. Keeping
+ * the lists here (not duplicated per dispatcher) means a new variant is added
+ * in exactly one place.
+ */
+declare const DOCX_FAMILY: ReadonlySet<string>;
+declare const XLSX_FAMILY: ReadonlySet<string>;
+declare const PPTX_FAMILY: ReadonlySet<string>;
+declare const ODF_FAMILY: ReadonlySet<string>;
+export { DOCX_FAMILY, ODF_FAMILY, PPTX_FAMILY, XLSX_FAMILY };

package/dist/use-cases/commands/office-to-markdown.d.ts

@@ -1,6 +1,10 @@
 import type { Result } from '../../domain/result.js';
 import type { GraphClient, GraphError } from '../../infra/graph-client.js';
 import type { FetchOptions } from './fetch-raw-bytes.js';
-declare const officeToMarkdown: (graph: GraphClient, contentPath: string, filename: string, opts?: FetchOptions) => Promise<Result<unknown, GraphError>>;
+type OfficeToMarkdownOptions = FetchOptions & {
+    readonly includeMetadata?: boolean;
+    readonly inlineImages?: boolean;
+    readonly maxCells?: number;
+};
+declare const officeToMarkdown: (graph: GraphClient, contentPath: string, filename: string, opts?: OfficeToMarkdownOptions) => Promise<Result<unknown, GraphError>>;
 export { officeToMarkdown };
-export type { FetchOptions };