kody-w Reformat every SharePoint result the same way so the person always gets a predictable, scannable table instead of a one-off dump, with a one-click path to open each item.
Core columns — always present
Every table, no matter the list type, keeps these:
- Title — the item's name (task title, file name, event name, contact name, etc.), plain text, not itself a link
- Person field(s) — every field the list actually carries that identifies a person: Assigned To, Owner, Created By, Author, Organizer, whichever apply. If a list has several distinct person fields, keep them all — identity/ownership is core context regardless of list type. If a field like Attendees holds multiple people, show up to 3 names then "+N more" rather than cramming the whole list into a cell.
- Description — if the item has a description/notes-style field, show only its first sentence, never the full text (see formatting conventions below for how to trim it)
- Modified — last modified date, reformatted per the conventions below
- Open — always the last column, always a link built from the fixed URL pattern below
If the list genuinely has no person field, or no description field, just drop that column rather than leaving it empty — "always present" means "always present when the underlying field exists," not padding in blank columns.
Column order left to right: Title, Description, person field(s), any dynamic columns (see below), Modified, Open.
Everything else — judge it dynamically
Beyond the core columns, decide what to include using two signals together, don't default to a fixed template:
- What the query is actually asking about. If the person asks about deadlines, add Due Date. If they ask what's urgent, add Priority. If they ask about file size or storage, add File Size. Let their own words point at the fields that matter — a query about "what's overdue" wants Due Date front and center; a query about "who's been editing this" wants Modified By over Created By.
- What's structurally central to that type of list — the field the table would be useless without, even if the person didn't spell it out. A task list without Status is hard to scan. A calendar table without the event's Date/Time defeats the point of showing it at all. Use judgment here the way a knowledgeable coworker would, not a rigid checklist.
Don't add a column just because the API happened to return that field — extra columns the query didn't ask for and the list type doesn't demand just add noise. Aim for lean, relevant tables: usually 4-6 columns total including the core ones.
Row order: preserve search relevance
Don't silently re-sort rows by date, name, or anything else. When results come from a search or query, keep the relevance order the search already returned — that ordering reflects how well each item matched what was asked, and re-sorting throws that signal away. Only change the order if the user explicitly asks for one ("sort by due date", "show me overdue items first", "group by owner").
Formatting conventions
- Dates: human-readable, e.g.
Jul 17, 2026— never raw ISO strings like2026-07-17T00:00:00Z - Missing/empty fields: an em dash
—, applied consistently — never a blank cell, never "N/A" in one row and "-" in another - Status: keep the list's own status label (don't paraphrase or invent new terms), but bold it when it signals something needing attention, e.g. Blocked, Overdue
- Description: show the first sentence only — split at the first
.,?, or!followed by a space or end of string. If that first sentence itself runs long (roughly 25+ words), truncate it with…rather than let one row blow out the table. Never include the full description text. - Other long text (comments, notes, anything that isn't the description field): still don't inline a full paragraph into a cell — leave it out or reduce it to a short phrase; "Open ↗" is there for anyone who wants the full text
Multiple lists or a broad search
If a query spans more than one SharePoint list, don't merge them into a single table with mismatched columns — each list type will have earned a different dynamic column set anyway. Give each source its own small heading and its own table:
### Project Tracker
| Title | Assigned To | Description | Status | Modified | Open |
|---|---|---|---|---|---|
| API rate limiting | Marcus Webb | Add throttling to the public endpoints… | **Blocked** | Jul 15, 2026 | [Open ↗](https://contoso.sharepoint.com/sites/Engineering/lists/Project%20Tracker/DispForm.aspx?ID=42) |
### Team Documents
| Title | Author | Modified | Open |
|---|---|---|---|
| Q3 Campaign Brief.docx | Sarah Nguyen | Jul 14, 2026 | [Open ↗](https://contoso.sharepoint.com/sites/Marketing/lists/Team%20Documents/DispForm.aspx?ID=118) |
Open link format — always this pattern
Don't link to whatever URL field the API happens to return (webUrl, _links.self, etc.). Every "Open" link is built from this fixed path, populated with real values pulled from the source data:
/sites/[site name]/lists/[list name]/DispForm.aspx?ID=[itemID]
- [site name] — the SharePoint site the list lives in (from the site URL/context in the source data)
- [list name] — the list's name (from the list title/internal name in the source data)
- [itemID] — the specific item's numeric ID (from the item's
ID/idfield)
Prefix the tenant's SharePoint domain if it's known (e.g. https://contoso.sharepoint.com + the path above) so the link is fully clickable;
Format the url as Markdown: Open ↗
Run this — do not improvise
This capability's deterministic implementation is a RAPP single-file agent, linked beside this file as sharepoint_list_formatter_agent.py and embedded as the fenced Python below (sha256 751dd92f185fd401…; a byte-exact copy is also vaulted in the capsule comment at the end of this file). On a host with sandbox execution, run the linked file directly — if it is missing, write the fence contents verbatim to sharepoint_list_formatter_agent.py first:
python3 sharepoint_list_formatter_agent.py '{"key": "value"}' # arguments as one JSON object
echo '{"key": "value"}' | python3 sharepoint_list_formatter_agent.py # or on stdin
python3 sharepoint_list_formatter_agent.py --tool # emit the JSON tool contract
Treat stdout as a tool result. If it reports missing or unresolved inputs, stop and collect them. If it returns steps, execute those steps in order exactly as returned; if it returns instructions, follow them with the supplied inputs. Otherwise use the result verbatim. Do not invent behavior beyond that output. On a host without code execution, treat the Parameters schema and the code below as the exact specification and never paraphrase a step. Never edit inside the generated markers; a converter-equipped host can instead restore the original file checksum-verified with the installed rapp-agent-converter/scripts/toast.py convert SKILL.md --to agent.
"""SharepointListFormatter -- Use this skill any time SharePoint list is being fetched, searched, or shown to the user — whether it comes from a SharePoint/Microsoft 365 connector, a search result, a pasted export, or a fetched SharePoint URL. Apply it instead of dumping raw JSON or an ad hoc table whenever the user asks to "pull," "check," "look up," "find," or "show" anything from a SharePoint list, even if they never say the word "format.".
Generated by the rapp skill from sharepoint-list-formatter. The RCI capsule at the bottom of this file carries the full original; `toast.py convert` restores it byte-exact."""
import json
import re
import sys
try:
from agents.basic_agent import BasicAgent
except ImportError: # running OUTSIDE a brainstem -- stay executable anyway.
class BasicAgent: # noqa: D101 - minimal stand-in, same contract
def __init__(self, name=None, metadata=None):
if name:
self.name = name
if metadata:
self.metadata = metadata
def perform(self, **kwargs):
return "Not implemented."
def system_context(self):
return None
def to_tool(self):
return {"type": "function", "function": {
"name": self.name,
"description": self.metadata.get("description", ""),
"parameters": self.metadata.get("parameters", {})}}
# The procedural layer, verbatim from the source capability.
INSTRUCTIONS = 'Reformat every SharePoint result the same way so the person always gets a predictable, scannable table instead of a one-off dump, with a one-click path to open each item.\n\n## Core columns — always present\nEvery table, no matter the list type, keeps these:\n\n- **Title** — the item's name (task title, file name, event name, contact name, etc.), plain text, not itself a link\n- **Person field(s)** — every field the list actually carries that identifies a person: Assigned To, Owner, Created By, Author, Organizer, whichever apply. If a list has several distinct person fields, keep them all — identity/ownership is core context regardless of list type. If a field like Attendees holds multiple people, show up to 3 names then "+N more" rather than cramming the whole list into a cell.\n- **Description** — if the item has a description/notes-style field, show only its first sentence, never the full text (see formatting conventions below for how to trim it)\n- **Modified** — last modified date, reformatted per the conventions below\n- **Open** — always the last column, always a link built from the fixed URL pattern below\n\nIf the list genuinely has no person field, or no description field, just drop that column rather than leaving it empty — "always present" means "always present when the underlying field exists," not padding in blank columns.\n\nColumn order left to right: Title, Description, person field(s), any dynamic columns (see below), Modified, Open.\n\n## Everything else — judge it dynamically\nBeyond the core columns, decide what to include using two signals together, don't default to a fixed template:\n\n1. **What the query is actually asking about.** If the person asks about deadlines, add Due Date. If they ask what's urgent, add Priority. If they ask about file size or storage, add File Size. Let their own words point at the fields that matter — a query about "what's overdue" wants Due Date front and center; a query about "who's been editing this" wants Modified By over Created By.\n2. **What's structurally central to that type of list** — the field the table would be useless without, even if the person didn't spell it out. A task list without Status is hard to scan. A calendar table without the event's Date/Time defeats the point of showing it at all. Use judgment here the way a knowledgeable coworker would, not a rigid checklist.\n\nDon't add a column just because the API happened to return that field — extra columns the query didn't ask for and the list type doesn't demand just add noise. Aim for lean, relevant tables: usually 4-6 columns total including the core ones.\n\n## Row order: preserve search relevance\nDon't silently re-sort rows by date, name, or anything else. When results come from a search or query, keep the relevance order the search already returned — that ordering reflects how well each item matched what was asked, and re-sorting throws that signal away. Only change the order if the user explicitly asks for one ("sort by due date", "show me overdue items first", "group by owner").\n\n## Formatting conventions\n- **Dates**: human-readable, e.g. `Jul 17, 2026` — never raw ISO strings like `2026-07-17T00:00:00Z`\n- **Missing/empty fields**: an em dash `—`, applied consistently — never a blank cell, never "N/A" in one row and "-" in another\n- **Status**: keep the list's own status label (don't paraphrase or invent new terms), but bold it when it signals something needing attention, e.g. **Blocked**, **Overdue**\n- **Description**: show the first sentence only — split at the first `.`, `?`, or `!` followed by a space or end of string. If that first sentence itself runs long (roughly 25+ words), truncate it with `…` rather than let one row blow out the table. Never include the full description text.\n- **Other long text** (comments, notes, anything that isn't the description field): still don't inline a full paragraph into a cell — leave it out or reduce it to a short phrase; "Open ↗" is there for anyone who wants the full text\n\n## Multiple lists or a broad search\nIf a query spans more than one SharePoint list, don't merge them into a single table with mismatched columns — each list type will have earned a different dynamic column set anyway. Give each source its own small heading and its own table:\n\n```\n### Project Tracker\n| Title | Assigned To | Description | Status | Modified | Open |\n|---|---|---|---|---|---|\n| API rate limiting | Marcus Webb | Add throttling to the public endpoints… | **Blocked** | Jul 15, 2026 | [Open ↗](https://contoso.sharepoint.com/sites/Engineering/lists/Project%20Tracker/DispForm.aspx?ID=42) |\n\n### Team Documents\n| Title | Author | Modified | Open |\n|---|---|---|---|\n| Q3 Campaign Brief.docx | Sarah Nguyen | Jul 14, 2026 | [Open ↗](https://contoso.sharepoint.com/sites/Marketing/lists/Team%20Documents/DispForm.aspx?ID=118) |\n```\n\n## Open link format — always this pattern\nDon't link to whatever URL field the API happens to return (`webUrl`, `_links.self`, etc.). Every "Open" link is built from this fixed path, populated with real values pulled from the source data:\n\n```\n/sites/[site name]/lists/[list name]/DispForm.aspx?ID=[itemID]\n```\n\n- **[site name]** — the SharePoint site the list lives in (from the site URL/context in the source data)\n- **[list name]** — the list's name (from the list title/internal name in the source data)\n- **[itemID]** — the specific item's numeric ID (from the item's `ID`/`id` field)\n\nPrefix the tenant's SharePoint domain if it's known (e.g. `https://contoso.sharepoint.com` + the path above) so the link is fully clickable;\n\nFormat the url as Markdown:\n[Open ↗](LINK)'
# Ordered commands lifted verbatim from the capability's own documentation.
STEPS = []
class SharepointListFormatterAgent(BasicAgent):
def __init__(self):
self.name = 'SharepointListFormatter'
self.metadata = {
"name": "SharepointListFormatter",
"description": "Use this skill any time SharePoint list is being fetched, searched, or shown to the user \u2014 whether it comes from a SharePoint/Microsoft 365 connector, a search result, a pasted export, or a fetched SharePoint URL. Apply it instead of dumping raw JSON or an ad hoc table whenever the user asks to \"pull,\" \"check,\" \"look up,\" \"find,\" or \"show\" anything from a SharePoint list, even if they never say the word \"format.\".",
"parameters": {
"type": "object",
"properties": {},
"required": []
}
}
super().__init__(name=self.name, metadata=self.metadata)
def perform(self, **kwargs): # toaster:generated-perform
return json.dumps({"status": "ok", "instructions": INSTRUCTIONS,
"inputs": kwargs,
"note": "Prose-only capability: follow INSTRUCTIONS "
"with the given inputs."}, indent=2)
if __name__ == "__main__":
# echo '{"arg": "value"}' | python3 sharepoint_list_formatter_agent.py
# python3 sharepoint_list_formatter_agent.py '{"arg": "value"}'
# python3 sharepoint_list_formatter_agent.py --tool # emit the JSON tool contract
_a = sys.argv[1:]
if _a and _a[0] == "--tool":
print(json.dumps(SharepointListFormatterAgent().to_tool(), indent=2))
else:
_raw = _a[0] if _a else (sys.stdin.read().strip() or "{}")
print(SharepointListFormatterAgent().perform(**json.loads(_raw)))
# rci-capsule:v1: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