@manudota/artist-mcp 2.3.1 → 2.3.2-staging.116

package/dist/dispatch.js

@@ -115,7 +115,9 @@ export const dispatchWith = (resolve, record = recordWrite) => async (op, params
         case 'list_notebooks':
             return (await listNotebooks(token));
         case 'list_notes':
-            return (await listNotes(token));
+            return (await listNotes(token, {
+                section: typeof params.section === 'string' ? params.section : undefined,
+            }));
         case 'map_notes':
             // The pages are chosen by the caller, which is where the notebook scope
             // is settled; nothing here maps a notebook it was not given.

package/dist/notes.d.ts

@@ -118,11 +118,26 @@ export declare const listNotebooks: (token: string) => Promise<{
  *
  * Do not "simplify" this back to the single call.
  */
-export declare const listNotes: (token: string) => Promise<{
+/** How a section name is compared: case and whitespace runs ignored, nothing else. */
+export declare const sectionKey: (name: string) => string;
+/** Graph caps a page listing here, and the walk does not page past it. See #178. */
+export declare const PAGE_LISTING_CAP = 100;
+export declare const listNotes: (token: string, { section }?: {
+    section?: string;
+}) => Promise<{
     notes: NoteSummary[];
     sections: SectionSummary[];
     /** Whether `last_modified` on every page is really its creation date. */
     page_dates_are_creation_dates: boolean;
+    /**
+     * Every section on the account, by name, when `section` narrowed the walk.
+     * The pages of the others were never fetched, so they carry no count — but a
+     * name that matched nothing still needs something to be compared against.
+     */
+    all_sections?: {
+        name: string;
+        notebook: string | null;
+    }[];
 }>;
 /**
  * The sections that changed within a window.

package/dist/notes.js

@@ -165,7 +165,11 @@ export const listNotebooks = async (token) => {
  *
  * Do not "simplify" this back to the single call.
  */
-export const listNotes = async (token) => {
+/** How a section name is compared: case and whitespace runs ignored, nothing else. */
+export const sectionKey = (name) => name.trim().replace(/\s+/g, ' ').toLowerCase();
+/** Graph caps a page listing here, and the walk does not page past it. See #178. */
+export const PAGE_LISTING_CAP = 100;
+export const listNotes = async (token, { section } = {}) => {
     const startedAt = Date.now();
     let sectionCount = 0;
     let failure = null;
@@ -177,13 +181,22 @@ export const listNotes = async (token) => {
         '/me/onenote/sections?$select=id,displayName,lastModifiedDateTime' +
             '&$expand=parentNotebook($select=displayName)&$top=100', token);
         const sections = (await sectionsRes.json()).value ?? [];
-        const usable = sections.filter((s) => typeof s.id === 'string' && ONENOTE_ID.test(s.id));
+        const valid = sections.filter((s) => typeof s.id === 'string' && ONENOTE_ID.test(s.id));
+        // Narrowed before the fan-out, which is the whole saving: one section's pages
+        // instead of every section's. Matched on the whole name, not a substring —
+        // "BCW" would otherwise walk every BCW project and hand back a page from the
+        // wrong one, and the update flow needs exactly one page.
+        //
+        // Runs of whitespace count as one space: a real section is named
+        // "BCW  Klagenfurt 03.07.2027 Vidala", and nobody types the second space.
+        const wanted = section === undefined ? undefined : sectionKey(section);
+        const usable = wanted === undefined ? valid : valid.filter((s) => sectionKey(s.displayName ?? '') === wanted);
         sectionCount = usable.length;
         const perSection = await mapWithConcurrency(usable, FANOUT_LIMIT, async (section) => {
             const res = await graphGet(`/me/onenote/sections/${section.id}/pages` +
                 // createdDateTime is selected only so the two can be compared. It
                 // costs nothing — the request is made either way.
-                '?$select=id,title,createdDateTime,lastModifiedDateTime&$top=100', token);
+                `?$select=id,title,createdDateTime,lastModifiedDateTime&$top=${PAGE_LISTING_CAP}`, token);
             const pages = (await res.json()).value ?? [];
             return pages.map((p) => ({
                 id: p.id,
@@ -210,7 +223,18 @@ export const listNotes = async (token) => {
         // Sections newest first for the same reason, and because when page dates are
         // useless this is the ordering the caller actually reads.
         const sectionList = sectionSummaries.sort((a, b) => (b.last_modified ?? '').localeCompare(a.last_modified ?? ''));
-        return { notes, sections: sectionList, page_dates_are_creation_dates: creationDates };
+        if (wanted === undefined) {
+            return { notes, sections: sectionList, page_dates_are_creation_dates: creationDates };
+        }
+        return {
+            notes,
+            sections: sectionList,
+            page_dates_are_creation_dates: creationDates,
+            all_sections: valid.map((s) => ({
+                name: s.displayName ?? '(unnamed section)',
+                notebook: s.parentNotebook?.displayName ?? null,
+            })),
+        };
     }
     catch (err) {
         failure = err instanceof Error ? err.message : String(err);

package/dist/server.d.ts

@@ -10,6 +10,14 @@ import { type Operation } from "./dispatch.js";
  * that is the point — there is one set of them, not two that drift.
  */
 type Dispatch = <T>(op: Operation, params?: Record<string, unknown>) => Promise<T>;
+type NoteSummary = {
+    id: string;
+    title: string;
+    section: string | null;
+    /** Absent from responses served by an older edge function. */
+    notebook?: string | null;
+    last_modified: string | null;
+};
 type AttachmentBody = {
     filename: string;
     mime_type: string;
@@ -58,6 +66,37 @@ type AttachmentMap = {
     }[];
     note: string | null;
 };
+/**
+ * The answer to a `section` that matched nothing, or matched more than one.
+ *
+ * Neither is allowed to fall through to a page list. The update flow resolves a
+ * chat message to exactly one page, and an empty list reads as "this project
+ * has no page" — which is a real finding for a section like BCW Megeve and a
+ * false one for a typo. So the names are offered, closest first, and choosing
+ * is left to the user.
+ */
+export declare const renderSectionMiss: (section: string, matched: {
+    name: string;
+    notebook: string | null;
+}[], all: {
+    name: string;
+    notebook: string | null;
+}[], 
+/** Set when the search spanned every notebook: names carry their notebook, and the key to choose one. */
+notebookKey?: string) => string | null;
+/**
+ * Which page in a resolved section an update belongs to (#193).
+ *
+ * Matched on the title's start, not the whole title: the live notebook names
+ * them `CL Aufgaben — Montepulciano`, plain `CL Aufgaben`, and
+ * `CL Aufgaben — Melk BCW (Barocktage 2027)`, and a whole-title convention
+ * would miss two of three. Computed from every page in the section, before
+ * `limit` or `since` trim the list, so a capped listing cannot hide it.
+ *
+ * None and several are both said outright. None is a real finding — the update
+ * has nowhere to go, and it must not land on a neighbouring page instead.
+ */
+export declare const renderUpdateTarget: (pages: readonly NoteSummary[]) => string;
 /**
  * Compose the briefing `list_agent_workflows` returns.
  *

package/dist/server.js

@@ -6,7 +6,7 @@ import { WRITE_CAPABILITIES, isGranted } from "./grants.js";
 import { listAgentWorkflows, loadAgentWorkflow } from "./agents.js";
 import { GraphError } from "./client.js";
 import { call as localCall } from "./dispatch.js";
-import { narrowNotes, narrowSections, notebookKeyFor } from "./notes.js";
+import { PAGE_LISTING_CAP, narrowNotes, narrowSections, notebookKeyFor, sectionKey } from "./notes.js";
 /** One call per page, so a notebook nobody put a number on does not become hundreds of requests. */
 const DEFAULT_MAP_PAGES = 40;
 /** Times are stated with their zone; the calendar's zone need not be the reader's. */
@@ -34,7 +34,7 @@ const describeSize = (bytes) => {
  * intake depends on, and two copies of it would eventually disagree. The caller
  * names itself so the instruction says which tool to call again.
  */
-const selectNotebook = async (call, notebook, notebookKey, tool) => {
+const selectNotebook = async (call, notebook, notebookKey, tool, section) => {
     // The notebook question first, and on its own, because it is the cheap one.
     //
     // `list_notes` answers it as a side effect of fetching every page of every
@@ -87,7 +87,7 @@ const selectNotebook = async (call, notebook, notebookKey, tool) => {
         return { message: `No notebook named "${notebook}". Available: ${names.join(", ")}.` };
     }
     // Settled. Only now are the pages worth what they cost.
-    const { notes, sections = [], page_dates_are_creation_dates = false, } = await call("list_notes");
+    const { notes, sections = [], page_dates_are_creation_dates = false, all_sections, } = await call("list_notes", section === undefined ? {} : { section });
     const pages = wanted
         ? notes.filter((n) => (n.notebook ?? "").trim().toLowerCase() === wanted)
         : notes;
@@ -115,6 +115,130 @@ const selectNotebook = async (call, notebook, notebookKey, tool) => {
         sections: inScope,
         creationDates: page_dates_are_creation_dates,
         scope,
+        allSections: wanted
+            ? all_sections?.filter((sec) => (sec.notebook ?? "").trim().toLowerCase() === wanted)
+            : all_sections,
+    };
+};
+/**
+ * The answer to a `section` that matched nothing, or matched more than one.
+ *
+ * Neither is allowed to fall through to a page list. The update flow resolves a
+ * chat message to exactly one page, and an empty list reads as "this project
+ * has no page" — which is a real finding for a section like BCW Megeve and a
+ * false one for a typo. So the names are offered, closest first, and choosing
+ * is left to the user.
+ */
+export const renderSectionMiss = (section, matched, all, 
+/** Set when the search spanned every notebook: names carry their notebook, and the key to choose one. */
+notebookKey) => {
+    if (matched.length === 1)
+        return null;
+    const label = (sec) => notebookKey === undefined ? sec.name : `${sec.name} (notebook: ${sec.notebook ?? "unknown"})`;
+    const callAgain = notebookKey === undefined
+        ? "call list_notes again with that section."
+        : "call list_notes again with that section, its notebook, and the notebook_key below";
+    // On its own line, so no sentence punctuation is ever read as part of it.
+    const keyLine = notebookKey === undefined ? "" : `\n\nnotebook_key: ${notebookKey}`;
+    if (matched.length > 1) {
+        const where = matched.map((sec) => `- ${label(sec)}`);
+        return (`${matched.length} sections are named "${section}":\n${where.join("\n")}\n\n` +
+            `Ask the user which one they mean, then ${callAgain}. Do not pick one — ` +
+            "the same project name in two seasons is two different projects." +
+            keyLine);
+    }
+    // Scored by how many words are shared, and only the best score is offered.
+    // Against the real notebook, "any shared word" named every BCW section for a
+    // single BCW typo — a list that long is no closer than the full one.
+    const needle = sectionKey(section);
+    const words = needle.split(" ").filter((w) => w.length > 2);
+    const score = (name) => {
+        const hay = sectionKey(name);
+        if (hay.includes(needle) || needle.includes(hay))
+            return words.length + 1;
+        return words.filter((w) => hay.split(" ").includes(w)).length;
+    };
+    const scored = all.map((sec) => ({ sec, s: score(sec.name) }));
+    const best = Math.max(0, ...scored.map(({ s }) => s));
+    const near = scored.filter(({ s }) => best > 0 && s === best).map(({ sec }) => label(sec));
+    return (`No section is named "${section}". ` +
+        (near.length > 0
+            ? `Closest: ${[...new Set(near)].join(", ")}. `
+            : `Sections: ${[...new Set(all.map(label))].join(", ")}. `) +
+        `Ask the user which one they mean rather than choosing, then ${callAgain}. ` +
+        "Do not read this as the project having no page." +
+        keyLine);
+};
+/**
+ * Which page in a resolved section an update belongs to (#193).
+ *
+ * Matched on the title's start, not the whole title: the live notebook names
+ * them `CL Aufgaben — Montepulciano`, plain `CL Aufgaben`, and
+ * `CL Aufgaben — Melk BCW (Barocktage 2027)`, and a whole-title convention
+ * would miss two of three. Computed from every page in the section, before
+ * `limit` or `since` trim the list, so a capped listing cannot hide it.
+ *
+ * None and several are both said outright. None is a real finding — the update
+ * has nowhere to go, and it must not land on a neighbouring page instead.
+ */
+export const renderUpdateTarget = (pages) => {
+    const targets = pages.filter((p) => sectionKey(p.title).startsWith("cl aufgaben"));
+    if (targets.length === 1) {
+        const [t] = targets;
+        return (`CL Aufgaben page in this section: "${t.title}" (id: ${t.id}). ` +
+            "An update to this project belongs on this page.");
+    }
+    if (targets.length === 0) {
+        return ("This section has no CL Aufgaben page, so an update to this project has " +
+            "no page to go to. Say so; do not write it onto another page in the section.");
+    }
+    return (`This section has ${targets.length} CL Aufgaben pages: ` +
+        targets.map((t) => `"${t.title}" (id: ${t.id})`).join(", ") +
+        ". Ask the user which one an update belongs on. Do not pick one.");
+};
+/**
+ * `section` with no notebook, on an account holding several: the update flow's
+ * case, since "Melk is confirmed" names a project and never a season.
+ *
+ * Section NAMES are searched across every notebook — they arrive in the one
+ * sections call either way, so this costs nothing. PAGES still come back only
+ * when exactly one section in exactly one notebook matched, and the reply names
+ * that notebook so the answer cannot silently drift into the wrong season.
+ * Everything else — two seasons, a partial name — goes back to the user with
+ * the notebook_key, the same proof `selectNotebook` asks for.
+ */
+const findSectionAcrossNotebooks = async (call, section) => {
+    const { notebooks } = await call("list_notebooks");
+    // One notebook is not a choice; the ordinary path already handles it.
+    if (notebooks.length <= 1)
+        return null;
+    const names = notebooks.map((n) => n.name);
+    const { notes, sections = [], page_dates_are_creation_dates = false, all_sections = [], } = await call("list_notes", { section });
+    const miss = renderSectionMiss(section, sections, all_sections, notebookKeyFor(names));
+    if (miss !== null)
+        return { message: miss };
+    const [found] = sections;
+    // A unique exact match is not proof of the right season. Found live:
+    // "Montepulciano" resolved to 2026-27 while "Montepulciano 2028" sat in
+    // 2027-28, and an update naming the festival could mean either.
+    const wanted = sectionKey(section);
+    const similar = all_sections.filter((sec) => {
+        const key = sectionKey(sec.name);
+        return key !== wanted && (key.includes(wanted) || wanted.includes(key));
+    });
+    const others = names.filter((name) => name.trim().toLowerCase() !== (found.notebook ?? "").trim().toLowerCase());
+    return {
+        pages: notes,
+        sections,
+        creationDates: page_dates_are_creation_dates,
+        scope: `Found in notebook "${found.notebook ?? "unknown"}", the only notebook with a ` +
+            `section of this name (others: ${others.join(", ")}). Name that notebook when ` +
+            "you answer, so the user can catch a wrong season." +
+            (similar.length > 0
+                ? " Similarly named, and possibly the project meant: " +
+                    similar.map((sec) => `${sec.name} (notebook: ${sec.notebook ?? "unknown"})`).join(", ") +
+                    ". If the update could belong to one of these, ask before using this section."
+                : ""),
     };
 };
 /**
@@ -176,7 +300,7 @@ const renderChangedSections = (chosen, notebook, since) => {
  * the only way OneNote allows a cell to change.
  */
 const INDEX_ENTRIES = 12;
-const serverVersion = '2.3.1'; // x-release-please-version
+const serverVersion = '2.3.2-staging.116'; // x-release-please-version
 const errorResult = (err) => {
     const message = err instanceof GraphError ? err.message : `Unexpected error: ${err}`;
     return { content: [{ type: "text", text: message }], isError: true };
@@ -349,10 +473,19 @@ const renderWorkflowBriefing = async (entries, load, writes = []) => {
                 "install time. Everything not listed here remains read-only, " +
                 "including all of OneNote.",
             ...writes.map((name) => `- ${name}: ${WRITE_CAPABILITIES[name]}`),
-            "A disputed or UNKNOWN value may never be written. If two pages " +
-                "disagree, or a field is unsettled, refuse the write and say why — " +
-                "a written value persists and other people see it, which is exactly " +
-                "the decision policy:divergence refuses to make.",
+            // Recording a dispute is not settling one. The CL Aufgaben pages
+            // carry a convention for it — the field becomes UNGEKLÄRT and both
+            // values go under "Widersprüchliche Angaben" — and the earlier
+            // wording ("may never be written") read as forbidding that too, in
+            // the one surface that outranks the playbook saying to do it (#193).
+            "A disputed or UNKNOWN value may never be written as though it were " +
+                "settled. If two sources disagree, or a field is unsettled, never " +
+                "write one side as the value — a written value persists and other " +
+                "people see it, which is exactly the decision policy:divergence " +
+                "refuses to make. Recording the dispute itself is allowed where the " +
+                "page has a place for it: both values with their origins, and the " +
+                "field left UNGEKLÄRT or UNKNOWN. Where it has no such place, write " +
+                "nothing for that field and say why.",
         ];
     return [
         ...alarm,
@@ -718,6 +851,14 @@ const createServer = async (call, grants = []) => {
             "notebook you happen to know the user has: a plausible guess here " +
             "is indistinguishable from their choice and produces a confident " +
             "answer about the wrong notebook."),
+        section: z
+            .string()
+            .optional()
+            .describe("Exact name of one section, to list only its pages. Much cheaper " +
+            "than the whole notebook, and the reply gives the section's full " +
+            "page count. Use it to find the one page an update belongs to. " +
+            "Works without `notebook`: the section is then looked for in every " +
+            "notebook, and the reply says which one it was found in."),
         notebook_key: z
             .string()
             .optional()
@@ -745,12 +886,20 @@ const createServer = async (call, grants = []) => {
             .describe("Cap the number of pages returned, newest first. The reply says how " +
             "many matched, so a capped list is never mistaken for the whole " +
             "notebook."),
-    }, async ({ notebook, notebook_key, since, limit }) => {
+    }, async ({ notebook, notebook_key, section, since, limit }) => {
         try {
-            const chosen = await selectNotebook(call, notebook, notebook_key, "list_notes");
+            const chosen = (section !== undefined && notebook === undefined
+                ? await findSectionAcrossNotebooks(call, section)
+                : null) ??
+                (await selectNotebook(call, notebook, notebook_key, "list_notes", section));
             if ("message" in chosen) {
                 return { content: [{ type: "text", text: chosen.message }] };
             }
+            if (section !== undefined) {
+                const miss = renderSectionMiss(section, chosen.sections, chosen.allSections ?? []);
+                if (miss !== null)
+                    return { content: [{ type: "text", text: miss }] };
+            }
             const selected = chosen.pages;
             // When page dates carry no modification information, a `since` question
             // is answered about SECTIONS instead — and answers with sections, not
@@ -774,6 +923,13 @@ const createServer = async (call, grants = []) => {
             // Narrowed only after the notebook is settled, so a `since` window can
             // never be what makes a notebook look empty enough to skip choosing.
             const { notes: shown, matched, undated } = narrowNotes(selected, { since, limit });
+            if (shown.length === 0 && section !== undefined && since === undefined) {
+                return {
+                    content: [
+                        { type: "text", text: `Section "${chosen.sections[0].name}" holds no pages.` },
+                    ],
+                };
+            }
             if (shown.length === 0) {
                 const scope = notebook ? `"${notebook}"` : "this account";
                 return {
@@ -805,6 +961,17 @@ const createServer = async (call, grants = []) => {
             const caveats = [];
             if (chosen.scope)
                 caveats.push(chosen.scope);
+            if (section !== undefined) {
+                caveats.push(renderUpdateTarget(chosen.pages));
+                const [sec] = chosen.sections;
+                // Stated whether or not it is short, because "has this page seen
+                // everything in its section" is answered against this number (#193).
+                caveats.push(sec.pages >= PAGE_LISTING_CAP
+                    ? `Section "${sec.name}" returned ${sec.pages} pages, which is the ` +
+                        "listing cap: there may be more that were not fetched (#178)."
+                    : `Section "${sec.name}" holds ${sec.pages} page${sec.pages === 1 ? "" : "s"}; ` +
+                        "this is all of them.");
+            }
             if (shown.length < matched) {
                 caveats.push(`Showing the ${shown.length} newest by date of ${matched} matching ` +
                     "pages. Raise `limit` or narrow with `since` for the rest.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manudota/artist-mcp",
-  "version": "2.3.1",
+  "version": "2.3.2-staging.116",
   "description": "MCP server that reads your OneNote notes in Claude Desktop or Codex, with optional Gmail and Calendar as supporting evidence. Signs in on your own machine; writes are opt-in per install.",
   "keywords": [
     "mcp",