rootr-cli 0.1.0 → 0.2.1

package/lib/client.js

@@ -465,4 +465,40 @@ export class RootrClient {
       method: 'DELETE',
     });
   }
+
+  // ---- Databases (rows) -------------------------------------------------
+
+  /** Database definition: { id, name, icon, path, properties[], views[], rowCount }. */
+  async getDatabase(databaseId) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}`);
+  }
+
+  /** All rows of a database, in position order. Returns the raw rows array. */
+  async listRows(databaseId) {
+    const data = await this.request(`/databases/${encodeURIComponent(databaseId)}/rows`);
+    if (Array.isArray(data)) return data;
+    if (data && Array.isArray(data.rows)) return data.rows;
+    return [];
+  }
+
+  async createRow(databaseId, { values, position } = {}) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/rows`, {
+      method: 'POST',
+      body: { values, position },
+    });
+  }
+
+  async updateRow(databaseId, rowId, { values, position } = {}) {
+    return this.request(
+      `/databases/${encodeURIComponent(databaseId)}/rows/${encodeURIComponent(rowId)}`,
+      { method: 'PATCH', body: { values, position } },
+    );
+  }
+
+  async deleteRow(databaseId, rowId) {
+    return this.request(
+      `/databases/${encodeURIComponent(databaseId)}/rows/${encodeURIComponent(rowId)}`,
+      { method: 'DELETE' },
+    );
+  }
 }

package/lib/mcp-tools/databases.js

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+
+import { jsonResult, errorResult, makeClient } from './shared.js';
+
+/**
+ * Resolve a `{propertyNameOrId: value}` map to `{propertyId: value}` using the
+ * database schema, so agents can address columns by their human name OR their
+ * id. `null` is preserved (clear marker for PATCH). Throws on an unknown key so
+ * the model is told to read the schema first.
+ */
+function resolveValueKeys(properties, values) {
+  const byId = new Map(properties.map((p) => [p.id, p]));
+  const byName = new Map(properties.map((p) => [p.name.toLowerCase(), p]));
+  const out = {};
+  for (const [key, v] of Object.entries(values || {})) {
+    const prop = byId.get(key) ?? byName.get(String(key).toLowerCase());
+    if (!prop) {
+      throw new Error(`Unknown property "${key}". Call rootr_read_database first to see the column ids/names.`);
+    }
+    out[prop.id] = v;
+  }
+  return out;
+}
+
+/**
+ * Database (Notion-style table/board/kanban) row tools. The REST layer already
+ * exposes GET /databases/:id (schema), GET/POST /databases/:id/rows and
+ * PATCH/DELETE /databases/:id/rows/:rowId — these tools wrap it so agents can
+ * read the schema, then create/move/edit/delete rows (e.g. change a select
+ * "status" column = move a kanban card between columns).
+ */
+export function registerDatabaseTools(server) {
+  server.registerTool(
+    'rootr_read_database',
+    {
+      title: 'Read a database schema and rows',
+      description:
+        'Read a Rootr (루터) DATABASE node — its schema (properties with ids/types and select options) plus all rows ' +
+        '(each with its rowId and values). ALWAYS call this before rootr_add_row / rootr_update_row so you know the exact ' +
+        'property ids/names and, for board/kanban views, which select column holds the status. Only works on DATABASE nodes.',
+      inputSchema: {
+        databaseId: z.string().describe('DATABASE node id'),
+      },
+    },
+    async ({ databaseId }) => {
+      try {
+        const client = makeClient();
+        const [database, rows] = await Promise.all([
+          client.getDatabase(databaseId),
+          client.listRows(databaseId),
+        ]);
+        return jsonResult({ database, rows });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_list_rows',
+    {
+      title: 'List database rows',
+      description:
+        'List the rows of a Rootr (루터) DATABASE (id + values + position), without the schema. ' +
+        'Use rootr_read_database instead when you also need the property/column definitions.',
+      inputSchema: {
+        databaseId: z.string().describe('DATABASE node id'),
+      },
+    },
+    async ({ databaseId }) => {
+      try {
+        const client = makeClient();
+        const rows = await client.listRows(databaseId);
+        return jsonResult({ rows });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_add_row',
+    {
+      title: 'Add a database row',
+      description:
+        'Append a row to a Rootr (루터) DATABASE. `values` maps property NAME (or id) → value. ' +
+        'Value shapes by type: title/text/url/select/person → string; number → number; multi_select → string[]; ' +
+        'checkbox → boolean; date → { start: "YYYY-MM-DD", end? }. A select value is the OPTION NAME. ' +
+        'Call rootr_read_database first to learn the columns. Optionally set `position` to insert at an index.',
+      inputSchema: {
+        databaseId: z.string().describe('DATABASE node id'),
+        values: z.record(z.unknown()).describe('{ propertyNameOrId: value } for the new row'),
+        position: z.number().optional().describe('0-based insert index; appended at the end if omitted'),
+      },
+    },
+    async ({ databaseId, values, position }) => {
+      try {
+        const client = makeClient();
+        const database = await client.getDatabase(databaseId);
+        const resolved = resolveValueKeys(database.properties || [], values);
+        const row = await client.createRow(databaseId, { values: resolved, position });
+        return jsonResult(row);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_update_row',
+    {
+      title: 'Update a database row',
+      description:
+        'Merge-patch ONE row of a Rootr (루터) DATABASE by rowId (get rowIds from rootr_read_database). ' +
+        '`values` maps property NAME (or id) → new value; only the passed keys change, `null` clears a key, omitted keys ' +
+        'are left unchanged. To MOVE a kanban card to another column, set its select/status property to the new option name. ' +
+        'Optionally set `position` to reorder the row.',
+      inputSchema: {
+        databaseId: z.string().describe('DATABASE node id'),
+        rowId: z.string().describe('Row id (must belong to the database)'),
+        values: z.record(z.unknown()).optional().describe('{ propertyNameOrId: newValue | null } partial patch'),
+        position: z.number().optional().describe('New 0-based position for the row'),
+      },
+    },
+    async ({ databaseId, rowId, values, position }) => {
+      try {
+        const client = makeClient();
+        let resolved;
+        if (values !== undefined) {
+          const database = await client.getDatabase(databaseId);
+          resolved = resolveValueKeys(database.properties || [], values);
+        }
+        const row = await client.updateRow(databaseId, rowId, { values: resolved, position });
+        return jsonResult(row);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_delete_row',
+    {
+      title: 'Delete a database row',
+      description:
+        'Delete ONE row of a Rootr (루터) DATABASE by rowId (its linked page, if any, is moved to the trash). ' +
+        'Verify the row via rootr_read_database first — do not guess rowIds.',
+      inputSchema: {
+        databaseId: z.string().describe('DATABASE node id'),
+        rowId: z.string().describe('Row id to delete (must belong to the database)'),
+      },
+    },
+    async ({ databaseId, rowId }) => {
+      try {
+        const client = makeClient();
+        await client.deleteRow(databaseId, rowId);
+        return jsonResult({ deleted: true, rowId });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}

package/lib/mcp-tools/presentations.js

@@ -0,0 +1,348 @@
+import { z } from 'zod';
+
+import { jsonResult, errorResult, makeClient, requireWorkspace } from './shared.js';
+
+/**
+ * Authoring guide, repeated (shortened) across every tool description so an
+ * agent that only sees ONE of these tools still gets the rules: assertion
+ * titles, text-spine-carries-meaning, 16:9 canvas, kind for slide role.
+ */
+const AUTHORING_GUIDE =
+  'Authoring guide: give each slide ONE assertion-style title (a claim, e.g. "Latency dropped 40% after the cache fix" — ' +
+  'not a topic label like "Latency"), plus blocks[] (bullet-like {id, heading?, body?, icon?} items) and, where useful, ' +
+  'a diagram ({type:"mermaid", code}) or images. Canvas is 16:9 (1280x720). Meaning must live in TEXT — ' +
+  'title/blocks[].heading/blocks[].body/notes are what auto-connects into the knowledge graph; diagrams/code/html and the ' +
+  'image pixels themselves are visual-only and are NOT indexed, so never put facts ONLY in a diagram or picture.\n' +
+  'Images: `image` is the single primary/background image (cover, section, full-bleed); `images[]` holds additional ' +
+  'inserted images placed on the slide. Each image is {id?, src?, alt?, placement?, prompt?, x?, y?, w?, h?}. ' +
+  'Set `src` to an uploaded file URL (upload via POST /v1/attachments/upload, then use /api/v1/attachments/{id}/raw), ' +
+  'an https URL, or a data: URI — you cannot upload the file bytes through these MCP tools, only reference the resulting URL. ' +
+  'To get a REAL image, call rootr_generate_image with an English prompt (say "no text"), then put the returned `url` ' +
+  'into the slide image\'s `src`; rootr_remove_image_background cuts out an image\'s background. ' +
+  '`placement` is a layout hint ("full"|"right"|"top"|...); x/y/w/h give freeform PPT-style placement in 1280x720 canvas ' +
+  'coords. ALWAYS add an `alt` caption to every image — alt text is part of the graph text spine, so a captioned image ' +
+  'connects into the knowledge graph while an uncaptioned one does not.\n' +
+  'Use kind to mark each slide\'s role: "cover" (deck title slide), "section" (chapter divider), "content" (body slide, ' +
+  'the default), "closing" (last slide / call to action).\n' +
+  'Page numbers: "content" and "section" slides automatically show a page number that follows the slide order (it ' +
+  're-numbers itself when slides are reordered), so you do NOT set it yourself. "cover"/"closing" have none by design.';
+
+/** Fill in slide/block ids that were omitted, so agents don't have to invent unique ids by hand. */
+function ensureSlideIds(slides) {
+  if (!Array.isArray(slides)) return slides;
+  return slides.map((s, i) => {
+    const slide = { ...s, id: s.id || `SLD-${String(i + 1).padStart(3, '0')}` };
+    if (Array.isArray(slide.blocks)) {
+      slide.blocks = slide.blocks.map((b, bi) => ({ ...b, id: b.id || `${slide.id}-B${bi + 1}` }));
+    }
+    return slide;
+  });
+}
+
+const imageShape = z
+  .object({
+    id: z.string().optional().describe('Stable image id (for multi-image slides). Auto-generated if omitted.'),
+    src: z
+      .string()
+      .optional()
+      .describe(
+        'Image URL: an uploaded file (/api/v1/attachments/{id}/raw — upload first via POST /v1/attachments/upload), ' +
+          'an https URL, or a data: URI. Omit and set `prompt` instead to have it AI-generated later.',
+      ),
+    alt: z
+      .string()
+      .optional()
+      .describe('Caption / alt text. Part of the knowledge-graph text spine — ALWAYS set this so the image is indexed.'),
+    prompt: z.string().optional().describe('English AI-generation prompt, no text baked into the image (used when src is absent)'),
+    placement: z.string().optional().describe('Layout hint: "full" | "right" | "top" | ...'),
+    x: z.number().optional().describe('Freeform placement X in 1280x720 canvas coords'),
+    y: z.number().optional().describe('Freeform placement Y in 1280x720 canvas coords'),
+    w: z.number().optional().describe('Freeform placement width in canvas coords'),
+    h: z.number().optional().describe('Freeform placement height in canvas coords'),
+  })
+  .describe('A slide image. Set src (uploaded/https/data: URI) or prompt (AI-generate); always add an alt caption.');
+
+const slideShape = z
+  .object({
+    id: z.string().optional().describe('Unique slide id, e.g. "SLD-001". Auto-generated if omitted.'),
+    kind: z.string().optional().describe('cover | section | content | closing'),
+    layout: z.string().optional().describe('Layout hint, e.g. "2-col" | "kpi-grid" | "timeline"'),
+    title: z.string().optional().describe('Assertion-style title (the claim this slide makes) — text spine'),
+    blocks: z
+      .array(
+        z.object({
+          id: z.string().optional().describe('Unique block id. Auto-generated if omitted.'),
+          heading: z.string().optional(),
+          body: z.string().optional(),
+          icon: z.string().optional().describe('Semantic hint, e.g. "shield" | "calendar" | "chip"'),
+        }),
+      )
+      .optional()
+      .describe('Bullet-like items — text spine'),
+    diagram: z
+      .object({ type: z.literal('mermaid').optional(), code: z.string() })
+      .optional()
+      .describe('Mermaid diagram; visual only, not indexed — keep the facts in title/blocks too'),
+    image: imageShape
+      .optional()
+      .describe('Single primary/background image (cover, section, full-bleed). See imageShape fields.'),
+    images: z
+      .array(imageShape)
+      .optional()
+      .describe('Additional inserted/uploaded images placed on the slide (up to 50). Each should carry an alt caption.'),
+    code: z.string().optional().describe('Code-first React slide source (max design freedom, advanced use)'),
+    html: z.string().optional().describe('Rendered self-contained slide HTML (usually machine-produced, not hand-authored)'),
+    notes: z.string().optional().describe('Speaker notes — text spine'),
+  })
+  .describe('A single slide. See tool description for the authoring guide.');
+
+const themeShape = z
+  .object({
+    colors: z
+      .object({
+        primary: z.string().optional(),
+        secondary: z.string().optional(),
+        accent: z.string().optional(),
+        bg: z.string().optional(),
+        text: z.string().optional(),
+        muted: z.string().optional(),
+      })
+      .optional(),
+    fonts: z.object({ heading: z.string().optional(), body: z.string().optional() }).optional(),
+    keyVisualStyle: z.string().optional(),
+  })
+  .optional()
+  .describe('Deck theme; missing keys fall back to sane defaults');
+
+/** PRESENTATION (slide deck) node tools: create/read/update deck, append + reorder + patch slides. */
+export function registerPresentationTools(server) {
+  server.registerTool(
+    'rootr_create_presentation',
+    {
+      title: 'Create a Rootr presentation (slide deck)',
+      description:
+        'Create a new PRESENTATION node (a slide deck) in a Rootr (루터) workspace, optionally seeded with an ' +
+        'initial theme and slides. ' +
+        AUTHORING_GUIDE,
+      inputSchema: {
+        name: z.string().optional().describe('Deck name/title'),
+        parentId: z.string().optional().describe('Parent folder/node id to create the deck under'),
+        theme: themeShape,
+        slides: z.array(slideShape).optional().describe('Initial slides, in order'),
+        config: z.record(z.unknown()).optional().describe('Free-form deck config/settings object'),
+        icon: z.string().optional().describe('Emoji icon for the deck node'),
+        workspace: z
+          .string()
+          .optional()
+          .describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ name, parentId, theme, slides, config, icon, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        const result = await client.createPresentation(ws, {
+          name,
+          parentId,
+          theme,
+          slides: ensureSlideIds(slides),
+          config,
+          icon,
+        });
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_read_presentation',
+    {
+      title: 'Read a Rootr presentation',
+      description:
+        'Read a Rootr (루터) PRESENTATION node — its theme and full slides array. Read this before ' +
+        'rootr_update_presentation / rootr_append_presentation_slides / rootr_reorder_presentation_slides so you ' +
+        'know the current slide ids and content.',
+      inputSchema: {
+        presentationId: z.string().describe('PRESENTATION node id'),
+      },
+    },
+    async ({ presentationId }) => {
+      try {
+        const client = makeClient();
+        const result = await client.getPresentation(presentationId);
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_update_presentation',
+    {
+      title: 'Update a Rootr presentation (theme/slides/config)',
+      description:
+        'Merge-patch a Rootr (루터) PRESENTATION: update theme and/or config, or REPLACE THE WHOLE slides array ' +
+        '(if you pass `slides`, it replaces every existing slide — call rootr_read_presentation first and resend ' +
+        'slides you want to keep, or use rootr_append_presentation_slides / rootr_update_presentation_slide instead ' +
+        'for incremental changes). ' +
+        AUTHORING_GUIDE,
+      inputSchema: {
+        presentationId: z.string().describe('PRESENTATION node id'),
+        theme: themeShape,
+        slides: z
+          .array(slideShape)
+          .optional()
+          .describe('COMPLETE slides array to set — omitted existing slides will be dropped'),
+        config: z.record(z.unknown()).optional().describe('Free-form deck config/settings object'),
+        icon: z.string().optional().describe('Emoji icon for the deck node'),
+      },
+    },
+    async ({ presentationId, theme, slides, config, icon }) => {
+      try {
+        const client = makeClient();
+        const result = await client.updatePresentation(presentationId, {
+          theme,
+          slides: ensureSlideIds(slides),
+          config,
+          icon,
+        });
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_append_presentation_slides',
+    {
+      title: 'Append slides to a Rootr presentation (preferred way to add slides)',
+      description:
+        'Append one or more slides to the END of a Rootr (루터) PRESENTATION, without touching existing slides. ' +
+        'PREFER this over rootr_update_presentation when you are only adding new slides. ' +
+        AUTHORING_GUIDE,
+      inputSchema: {
+        presentationId: z.string().describe('PRESENTATION node id'),
+        slides: z.array(slideShape).describe('Slides to append, in order'),
+      },
+    },
+    async ({ presentationId, slides }) => {
+      try {
+        const client = makeClient();
+        const result = await client.appendPresentationSlides(presentationId, ensureSlideIds(slides));
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_update_presentation_slide',
+    {
+      title: 'Update ONE slide of a Rootr presentation',
+      description:
+        'Merge-patch a single slide by slideId, without touching the rest of the deck. Good for a precise, ' +
+        'targeted edit (e.g. rewrite one slide\'s title/blocks); use rootr_append_presentation_slides instead when ' +
+        'you are only adding new slides. Call rootr_read_presentation first to get the exact slideId. ' +
+        AUTHORING_GUIDE,
+      inputSchema: {
+        presentationId: z.string().describe('PRESENTATION node id'),
+        slideId: z.string().describe('Slide id to update (must belong to the deck)'),
+        slide: slideShape.describe('Partial slide fields to merge into the existing slide'),
+      },
+    },
+    async ({ presentationId, slideId, slide }) => {
+      try {
+        const client = makeClient();
+        const result = await client.updatePresentationSlide(presentationId, slideId, slide);
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_reorder_presentation_slides',
+    {
+      title: 'Reorder the slides of a Rootr presentation',
+      description:
+        'Reorder a Rootr (루터) PRESENTATION\'s slides. `order` must be the FULL list of the deck\'s slide ids, ' +
+        'in the new desired order — call rootr_read_presentation first to get the current ids.',
+      inputSchema: {
+        presentationId: z.string().describe('PRESENTATION node id'),
+        order: z.array(z.string()).describe('Complete ordered array of slide ids'),
+      },
+    },
+    async ({ presentationId, order }) => {
+      try {
+        const client = makeClient();
+        const result = await client.reorderPresentationSlides(presentationId, order);
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_generate_image',
+    {
+      title: 'Generate an image from a text prompt (for a slide)',
+      description:
+        'Generate an image from a text prompt with AI (Gemini) and store it as a workspace attachment. Use this ' +
+        'when building a Rootr (루터) presentation so slides get real, on-brand visuals instead of empty image ' +
+        'placeholders — generate the image, then put the returned `url` into a slide image\'s `src` via ' +
+        'rootr_update_presentation_slide (image or images[]). Returns { id, url, filename, mimeType, size }.\n' +
+        'Prompt tips: describe a clean, flat, presentation-ready illustration; specify colors to match the deck ' +
+        'theme; and say "no text" — baked-in text is not indexed and often renders wrong (put the meaning in the ' +
+        'slide title/blocks instead, and always give the image an `alt` caption). Consumes AI credits.',
+      inputSchema: {
+        prompt: z.string().describe('English image description; ask for "no text" in the image'),
+        nodeId: z.string().optional().describe('Presentation/node id to attach the image to (permission-checked)'),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config'),
+      },
+    },
+    async ({ prompt, nodeId, workspace }) => {
+      try {
+        const client = makeClient();
+        const ws = requireWorkspace(workspace);
+        const result = await client.generateImage(ws, { prompt, nodeId });
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_remove_image_background',
+    {
+      title: 'Remove the background of an image',
+      description:
+        'Remove the background of an existing Rootr (루터) workspace attachment (e.g. a generated or uploaded image) ' +
+        'and store the result as a new transparent PNG. Pass the source attachment id; returns { id, url, ... } for ' +
+        'the cut-out image, which you can then place on a slide. Useful for product shots / logos / subjects that ' +
+        'should sit on the slide without a boxed background.',
+      inputSchema: {
+        attachmentId: z.string().describe('Source attachment id (from rootr_generate_image or an upload)'),
+        nodeId: z.string().optional().describe('Presentation/node id to attach the result to (permission-checked)'),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config'),
+      },
+    },
+    async ({ attachmentId, nodeId, workspace }) => {
+      try {
+        const client = makeClient();
+        const ws = requireWorkspace(workspace);
+        const result = await client.removeImageBackground(ws, { attachmentId, nodeId });
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}

package/lib/mcp-tools/workspaces.js

@@ -2,6 +2,26 @@ import { z } from 'zod';
 
 import { textResult, jsonResult, errorResult, makeClient, requireWorkspace } from './shared.js';
 
+/**
+ * Scaffold `tree` argument schema. Declared as an ARRAY of node objects so MCP
+ * clients serialize the value as real JSON. A bare `z.any()` emits an empty
+ * JSON Schema (no type), which some clients send as a stringified blob — the
+ * scaffold API then rejects it with "tree must be an array". The `.or(z.string())`
+ * branch plus parseTree() keeps any client that still stringifies working.
+ * Mirrors the typed-array pattern already used in logs.js.
+ */
+const treeArg = (desc) => z.array(z.record(z.any())).or(z.string()).describe(desc);
+
+/** Accept either a real array (typed clients) or a JSON string (clients that stringify structured args). */
+function parseTree(tree) {
+  if (typeof tree !== 'string') return tree;
+  try {
+    return JSON.parse(tree);
+  } catch {
+    throw new Error('tree must be a JSON array of node objects (received an unparseable string)');
+  }
+}
+
 /** Workspace listing and scaffolding tools: rootr_workspaces, rootr_scaffold_plan, rootr_create_workspace, rootr_scaffold_apply. */
 export function registerWorkspaceTools(server) {
   server.registerTool(
@@ -70,13 +90,13 @@ export function registerWorkspaceTools(server) {
       inputSchema: {
         name: z.string().describe('Name for the new workspace'),
         intent: z.string().optional().describe('Original natural-language intent, for reference/regeneration'),
-        tree: z.any().describe('Scaffold tree to populate the new workspace with (see llms.txt tree schema)'),
+        tree: treeArg('Scaffold tree — an ARRAY of node objects to populate the new workspace with (see llms.txt tree schema)'),
       },
     },
     async ({ name, intent, tree }) => {
       try {
         const client = makeClient();
-        const result = await client.createWorkspaceScaffold({ name, intent, tree });
+        const result = await client.createWorkspaceScaffold({ name, intent, tree: parseTree(tree) });
         return jsonResult(result);
       } catch (err) {
         return errorResult(err);
@@ -96,7 +116,7 @@ export function registerWorkspaceTools(server) {
         'AFTER creating: if your runtime can receive HTTP callbacks, offer a webhook on the new subtree ' +
         '(rootr_create_webhook with scopeNodeId) so changes flow back to you — skip your own actorId.',
       inputSchema: {
-        tree: z.any().describe('Scaffold tree to create (see llms.txt tree schema)'),
+        tree: treeArg('Scaffold tree — an ARRAY of node objects to create (see llms.txt tree schema)'),
         rootPath: z.string().optional().describe('Existing path to root the new tree under, e.g. "/projects"'),
         workspace: z
           .string()
@@ -108,7 +128,7 @@ export function registerWorkspaceTools(server) {
       try {
         const ws = requireWorkspace(workspace);
         const client = makeClient(ws);
-        const result = await client.scaffoldApply(ws, { rootPath, tree });
+        const result = await client.scaffoldApply(ws, { rootPath, tree: parseTree(tree) });
         return jsonResult(result);
       } catch (err) {
         return errorResult(err);

package/lib/mcp.js

@@ -6,6 +6,7 @@ import { registerWorkspaceTools } from './mcp-tools/workspaces.js';
 import { registerLogTools } from './mcp-tools/logs.js';
 import { registerAskTools } from './mcp-tools/ask.js';
 import { registerIssueTools } from './mcp-tools/issues.js';
+import { registerDatabaseTools } from './mcp-tools/databases.js';
 import { registerWebhookTools } from './mcp-tools/webhooks.js';
 import { registerMiscTools } from './mcp-tools/misc.js';
 
@@ -20,7 +21,9 @@ export async function startMcpServer({ name, version }) {
         'rootr_edit for targeted changes; use rootr_write only for full rewrites. Beyond documents, this ' +
         'server also covers workspace scaffolding (planning/creating/applying document trees), typed LOG ' +
         'datastores (structured entries + stats), GraphRAG root-cause Q&A (rootr_ask), GitHub-style issue ' +
-        'trackers, and webhooks.\n\n' +
+        'trackers, DATABASE rows (read schema + rows, add/update/delete rows — e.g. move a kanban card by ' +
+        'changing its status column, via rootr_read_database / rootr_add_row / rootr_update_row / rootr_delete_row), ' +
+        'and webhooks.\n\n' +
         'Node types — pick the block that fits, never fake everything with markdown files: ' +
         'DOCUMENT = free-form markdown narrative (overviews, specs, decision logs); ' +
         'DATABASE = typed columns + views (table/board/calendar/timeline) for anything trackable — tasks, requirements, risks, milestones; ' +
@@ -42,6 +45,7 @@ export async function startMcpServer({ name, version }) {
   registerLogTools(server);
   registerAskTools(server);
   registerIssueTools(server);
+  registerDatabaseTools(server);
   registerWebhookTools(server);
   registerMiscTools(server);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Official Rootr CLI + MCP server — read, write, edit and search Rootr documents from the shell or from an AI agent.",
   "type": "module",
   "bin": {
@@ -14,17 +14,7 @@
     "lib",
     "README.md"
   ],
-  "keywords": [
-    "rootr",
-    "mcp",
-    "model-context-protocol",
-    "ai-agent",
-    "knowledge-base",
-    "markdown",
-    "cli"
-  ],
-  "homepage": "https://rootr.io",
-  "license": "MIT",
+  "license": "UNLICENSED",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "zod": "^3.23.8"