rootr-cli 0.7.1 → 0.8.1

package/README.md

@@ -296,15 +296,20 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 
 | 도구 | 설명 |
 |---|---|
-| `rootr_read_database` | 스키마(열 정의)+행 전체 읽기 — **다른 표 도구를 쓰기 전에 먼저** |
-| `rootr_list_rows` | 행만 조회(스키마 제외) |
-| `rootr_add_row` | 행 추가 (`values`는 열 이름 또는 id로 지정) |
-| `rootr_update_row` | 행 수정 (칸반 카드 이동 = select 열 값 변경) |
+| `rootr_read_database` | 스키마(열 정의)+행 전체 읽기 — **다른 표 도구를 쓰기 전에 먼저** (`includeBody: true` 면 행마다 상세 내용까지) |
+| `rootr_list_rows` | 행만 조회(스키마 제외, `includeBody` 지원) |
+| `rootr_add_row` | 행 추가 (`values`는 열 이름 또는 id로 지정, `body`로 상세 내용까지) |
+| `rootr_update_row` | 행 수정 (칸반 카드 이동 = select 열 값 변경, `body`로 상세 내용 교체) |
 | `rootr_delete_row` | 행 삭제 |
 | `rootr_add_column` | **열 추가** — 기존 열·행은 그대로 |
 | `rootr_update_column` | 열 이름 변경 / select 선택지 교체 |
 | `rootr_delete_column` | 열 삭제(파괴적) |
 
+행의 **상세 내용(본문 메모)** — 화면에서 칸반 카드를 열면 속성 아래에 적는 그 글 — 은
+`body`로 오갑니다. 실체는 표 밑에 달리는 문서 한 장이고, 없으면 쓸 때 만들어집니다.
+명령줄에서도 됩니다: `rootr db row-add <표> --values '{"제목":"킥오프"}' --body "..."`,
+`rootr db row-body <표> <rowId> --file memo.md`, `rootr db rows <표> --body`.
+
 열은 **한 번에 하나씩** 다룹니다. REST의 `PATCH /databases/:id`는 `properties`
 배열을 통째로 교체하기 때문에, 에이전트가 배열을 다시 만들다 빠뜨린 열이 그대로
 사라집니다. 위 세 도구는 서버가 병합하므로 나머지 열이 없어지지 않습니다.

package/bin/rootr.js

@@ -26,6 +26,10 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr ws                                         내 워크스페이스 목록 (id\tname, 열 수 없는 곳은 표시)
   rootr use <id|이름|주소>                          활성 워크스페이스 전환 (그 워크스페이스용 키도 기억)
   rootr ask <question> [--workspace <w>]           GraphRAG 질의응답 (RCA), 인용 포함 출력
+  rootr db create [--file <spec.json>] [--parent <path|id>]  표(DATABASE) 생성 — 컬럼 순서 그대로, 행까지 한 번에
+  rootr db rows <path|id> [--body] [--json]        표의 행 목록 (--body: 상세 내용까지)
+  rootr db row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  행 추가(상세 내용 포함)
+  rootr db row-body <path|id> <rowId> [--file <f>] 행의 상세 내용(본문 메모) 쓰기 — 없으면 표준입력
   rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  설정 조회/저장
   rootr config --add-key <k> [--label <name>] [--workspace <w>]     워크스페이스별 키 추가 등록
   rootr mcp                                        MCP stdio 서버 구동 (도구 90종+ — README 참고)
@@ -433,6 +437,127 @@ async function cmdMcp() {
 
 // ---- entry ------------------------------------------------------------
 
+
+/**
+ * 표(DATABASE) 만들기 — 컬럼 순서를 그대로 지키려면 한 번에 만들어야 한다.
+ *
+ * 스펙은 JSON으로 받는다(파일 또는 표준입력): `{ name, properties[], views?, rows? }`.
+ * 컬럼을 하나씩 붙이는 방식은 호출 순서가 곧 컬럼 순서가 되어 옮겨온 표가 뒤죽박죽이
+ * 됐다 — 그래서 CLI도 "한 번에" 쪽만 제공한다.
+ */
+async function cmdDb(args) {
+  const sub = args._[0];
+  if (sub === 'rows') return cmdDbRows(args);
+  if (sub === 'row-add') return cmdDbRowAdd(args);
+  if (sub === 'row-body') return cmdDbRowBody(args);
+  if (sub !== 'create') {
+    throw new Error(
+      '사용법: rootr db create|rows|row-add|row-body … (자세한 건 rootr --help)',
+    );
+  }
+  const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();
+  let spec;
+  try {
+    spec = JSON.parse(raw);
+  } catch {
+    throw new Error('스펙을 JSON으로 읽을 수 없습니다. { "name": "...", "properties": [...] } 형태여야 합니다.');
+  }
+  if (!spec.name && !spec.path) throw new Error('스펙에 name 또는 path가 있어야 합니다.');
+
+  const client = makeClient();
+  let parentId = spec.parentId;
+  if (typeof args.parent === 'string') {
+    const resolved = await resolveTarget(client, args.parent);
+    if (!resolved.existed) throw new Error(`부모를 찾을 수 없습니다: ${args.parent}`);
+    parentId = resolved.id;
+  }
+  const ws = args.ws || client.workspace;
+  if (!ws) throw new Error('워크스페이스를 알 수 없습니다. --ws 를 주거나 rootr use 로 정하세요.');
+
+  const db = await client.createDatabase(ws, { ...spec, parentId });
+  const cols = (db.properties || []).map((p) => p.name).join(', ');
+  console.log(`표 생성: ${db.path ?? db.name}  (${db.id})`);
+  if (cols) console.log(`컬럼 순서: ${cols}`);
+  if (typeof db.rowCount === 'number') console.log(`행: ${db.rowCount}개`);
+}
+
+/** 표의 행 목록. --body 를 주면 행마다 상세 내용(본문 메모)까지 가져온다. */
+async function cmdDbRows(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr db rows <path|id> [--body] [--json]');
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const rows = await client.listRows(id, { withBody: !!args.body });
+  if (args.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  for (const row of rows) {
+    const values = Object.values(row.values || {})
+      .map((v) => (v && typeof v === 'object' ? JSON.stringify(v) : String(v)))
+      .join(' | ');
+    console.log(`${row.id}\t${values}`);
+    if (args.body && row.body) {
+      for (const line of String(row.body).trimEnd().split('\n')) console.log(`    ${line}`);
+    }
+  }
+}
+
+/** 행 추가. 값은 JSON으로, 상세 내용(본문 메모)은 --body / --body-file 로. */
+async function cmdDbRowAdd(args) {
+  const target = args._[1];
+  if (!target || typeof args.values !== 'string') {
+    throw new Error("사용법: rootr db row-add <path|id> --values '{\"제목\":\"...\"}' [--body <md>|--body-file <f>]");
+  }
+  let values;
+  try {
+    values = JSON.parse(args.values);
+  } catch {
+    throw new Error('--values 는 JSON이어야 합니다. 예: --values \'{"제목":"킥오프"}\'');
+  }
+  const body =
+    typeof args['body-file'] === 'string'
+      ? readFileSync(args['body-file'], 'utf8')
+      : typeof args.body === 'string'
+        ? args.body
+        : undefined;
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const row = await client.createRow(id, { values, body });
+  console.log(`행 추가: ${row.id}`);
+  if (row.pageNodeId) console.log(`상세 내용 문서: ${row.pageNodeId}`);
+}
+
+/** 행의 상세 내용(본문 메모)을 통째로 쓴다. 내용은 인자·--file·표준입력 순으로 받는다. */
+async function cmdDbRowBody(args) {
+  const target = args._[1];
+  const rowId = args._[2];
+  if (!target || !rowId) {
+    throw new Error('사용법: rootr db row-body <path|id> <rowId> [<본문>] [--file <f>]');
+  }
+  const body =
+    typeof args.file === 'string'
+      ? readFileSync(args.file, 'utf8')
+      : args._[3] !== undefined
+        ? String(args._[3])
+        : await readStdin();
+  if (!body) throw new Error('쓸 내용이 없습니다 (본문 인자, --file, 또는 표준입력 필요).');
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const row = await client.updateRow(id, rowId, { body });
+  console.log(`상세 내용 저장: 행 ${rowId}${row.pageNodeId ? ` → 문서 ${row.pageNodeId}` : ''}`);
+}
+
+/** 경로로 줘도 되게 — 표 인자도 문서 도구들과 같은 규칙을 따른다. */
+async function resolveDatabaseId(client, target) {
+  if (typeof target === 'string' && target.startsWith('/')) {
+    const resolved = await resolveTarget(client, target);
+    if (!resolved.existed) throw new Error(`표를 찾을 수 없습니다: ${target}`);
+    return resolved.id;
+  }
+  return target;
+}
+
 async function main() {
   const argv = process.argv.slice(2);
   const args = parseArgs(argv);
@@ -474,6 +599,8 @@ async function main() {
       return cmdConfig(args);
     case 'use':
       return cmdUse(args);
+    case 'db':
+      return cmdDb(args);
     case 'mcp':
       return cmdMcp(args);
     default:

package/lib/client.js

@@ -550,32 +550,97 @@ export class RootrClient {
     });
   }
 
-  // ---- Databases (rows) -------------------------------------------------
+  // ---- Templates ---------------------------------------------------------
+  // 문서 양식(템플릿). 인앱 어시스턴트는 예전부터 쓸 수 있었는데 MCP·CLI에는
+  // 없어서, 밖에서 붙은 에이전트는 양식이 있는 줄도 모르고 매번 맨바닥부터
+  // 만들었다(2026-08-18 점검에서 드러난 구멍).
+
+  async listTemplates(workspace) {
+    return this.request(`/workspaces/${encodeURIComponent(workspace)}/templates`);
+  }
+
+  async applyTemplate(workspace, templateId, { parentId } = {}) {
+    return this.request(
+      `/workspaces/${encodeURIComponent(workspace)}/templates/${encodeURIComponent(templateId)}/apply`,
+      { method: 'POST', body: { parentId } },
+    );
+  }
+
+  async createTemplate(workspace, { name, emoji, description, kind, spec } = {}) {
+    return this.request(`/workspaces/${encodeURIComponent(workspace)}/templates`, {
+      method: 'POST',
+      body: { name, emoji, description, kind, spec },
+    });
+  }
+
+  async saveTemplateFromNode(workspace, nodeId, { name, emoji, description } = {}) {
+    return this.request(
+      `/workspaces/${encodeURIComponent(workspace)}/templates/from-node/${encodeURIComponent(nodeId)}`,
+      { method: 'POST', body: { name, emoji, description } },
+    );
+  }
+
+  async updateTemplate(workspace, templateId, patch = {}) {
+    return this.request(
+      `/workspaces/${encodeURIComponent(workspace)}/templates/${encodeURIComponent(templateId)}`,
+      { method: 'PATCH', body: patch },
+    );
+  }
+
+  // ---- Databases --------------------------------------------------------
+
+  /**
+   * Create a DATABASE node with its columns (and optionally its first rows) in
+   * ONE call. `properties` order IS the column order — that is the whole point:
+   * building a table by adding columns one at a time made the order depend on
+   * the order of the calls, which is how migrated tables came out scrambled.
+   */
+  async createDatabase(workspace, { name, parentId, path, createParents, autoRename, icon, properties, views, rows } = {}) {
+    return this.request(`/workspaces/${encodeURIComponent(workspace)}/databases`, {
+      method: 'POST',
+      body: { name, parentId, path, createParents, autoRename, icon, properties, views, rows },
+    });
+  }
+
+  /**
+   * 뷰 하나만 고친다(이름·감출 컬럼·그룹 기준). PATCH /databases/:id 는 views 배열을
+   * 통째로 갈아끼워서 빠뜨린 뷰가 사라지는데, 여기서는 서버가 그 뷰만 병합한다.
+   */
+  async updateDatabaseView(databaseId, viewId, patch = {}) {
+    return this.request(
+      `/databases/${encodeURIComponent(databaseId)}/views/${encodeURIComponent(viewId)}`,
+      { method: 'PATCH', body: patch },
+    );
+  }
 
   /** 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`);
+  /**
+   * All rows of a database, in position order. Returns the raw rows array.
+   * DB-BODY — `withBody` 를 주면 행마다 상세 내용(본문 메모)까지 함께 온다.
+   */
+  async listRows(databaseId, { withBody = false } = {}) {
+    const query = withBody ? '?body=1' : '';
+    const data = await this.request(`/databases/${encodeURIComponent(databaseId)}/rows${query}`);
     if (Array.isArray(data)) return data;
     if (data && Array.isArray(data.rows)) return data.rows;
     return [];
   }
 
-  async createRow(databaseId, { values, position } = {}) {
+  async createRow(databaseId, { values, position, body } = {}) {
     return this.request(`/databases/${encodeURIComponent(databaseId)}/rows`, {
       method: 'POST',
-      body: { values, position },
+      body: { values, position, body },
     });
   }
 
-  async updateRow(databaseId, rowId, { values, position } = {}) {
+  async updateRow(databaseId, rowId, { values, position, body } = {}) {
     return this.request(
       `/databases/${encodeURIComponent(databaseId)}/rows/${encodeURIComponent(rowId)}`,
-      { method: 'PATCH', body: { values, position } },
+      { method: 'PATCH', body: { values, position, body } },
     );
   }
 

package/lib/mcp-tools/databases.js

@@ -1,10 +1,27 @@
 import { z } from 'zod';
 
-import { jsonResult, errorResult, makeClient, resolveNodeId, NODE_TARGET_HINT } from './shared.js';
+import {
+  jsonResult,
+  errorResult,
+  makeClient,
+  requireWorkspace,
+  resolveNodeId,
+  resolveOptionalNodeId,
+  NODE_TARGET_HINT,
+} from './shared.js';
 
 /** Human text for the `databaseId` param — accepts a path just like the document tools. */
 const DATABASE_TARGET_DESC = `DATABASE node id${NODE_TARGET_HINT} (e.g. "/제작 공정/칸반")`;
 
+/**
+ * DB-BODY — 행의 상세 내용(본문 메모). 화면에서 칸반 카드를 열면 속성 아래에 붙는 그 글이며,
+ * 실체는 표 밑에 달리는 문서 하나다. 예전에는 REST 2단계로만 닿을 수 있어서 CLI·MCP에서는
+ * 아예 손댈 수 없었다.
+ */
+const BODY_DESC =
+  "The row's detail body — the note shown under a kanban card's properties, in markdown " +
+  '(행의 상세 내용/본문 메모). Creates the row\'s page on demand; replaces the whole body.';
+
 /**
  * Resolve a `{propertyNameOrId: value}` map to `{propertyId: value}` using the
  * database schema, so agents can address columns by their human name OR their
@@ -33,6 +50,118 @@ function resolveValueKeys(properties, values) {
  * "status" column = move a kanban card between columns).
  */
 export function registerDatabaseTools(server) {
+  server.registerTool(
+    'rootr_create_database',
+    {
+      title: 'Create a Rootr database (table / board / kanban)',
+      description:
+        'Create a DATABASE node — a typed table with columns, views and rows — in ONE call, optionally seeded with ' +
+        'its first rows. **Use this whenever you need a table**: moving a Notion database over, building a kanban ' +
+        'board, a task/requirement/risk tracker, anything with trackable rows. Do NOT fake a table with a markdown ' +
+        'document, and do NOT create an empty database and then add columns one by one — `properties` order IS the ' +
+        'column order, so one call keeps the columns in exactly the order you list them. ' +
+        'The FIRST property must be type "title" (the row label). Other types: text | number | select | ' +
+        'multi_select | date | checkbox | url | person. select/multi_select take options:[{name,color}]. ' +
+        'Views default to a single table view; a "board" view needs config.groupBy = a select property id, a ' +
+        '"timeline" view needs config.dateProp. Row `values` are keyed by column NAME (or id); date values are ' +
+        '{ start: "YYYY-MM-DD", end? }, multi_select is string[].',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        name: z.string().describe('Table name, e.g. "업무 목록"'),
+        parentId: z.string().optional().describe(`Parent folder id${NODE_TARGET_HINT}; workspace root if omitted`),
+        path: z.string().optional().describe('Full path incl. name — wins over parentId+name, e.g. "/팀/업무 목록"'),
+        createParents: z.boolean().optional().describe('Create missing folders in `path` (default false)'),
+        icon: z.string().optional().describe('Emoji icon for the node'),
+        properties: z
+          .array(
+            z.object({
+              name: z.string().describe('Column header, e.g. "담당자"'),
+              type: z
+                .enum(['title', 'text', 'number', 'select', 'multi_select', 'date', 'checkbox', 'url', 'person'])
+                .describe('Column type; the FIRST property must be "title"'),
+              options: z
+                .array(z.object({ name: z.string(), color: z.string() }))
+                .optional()
+                .describe('select/multi_select only: the choices'),
+            }),
+          )
+          .optional()
+          .describe('Columns IN DISPLAY ORDER. Defaults to a single title column named "Name".'),
+        views: z
+          .array(z.record(z.unknown()))
+          .optional()
+          .describe('Views, e.g. [{ name: "보드", type: "board", config: { groupBy: "<select property id>" } }]'),
+        rows: z
+          .array(z.object({ values: z.record(z.unknown()) }))
+          .optional()
+          .describe('Initial rows, e.g. [{ values: { "이름": "킥오프", "기한": { "start": "2026-08-01" } } }]'),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ name, parentId, path, createParents, icon, properties, views, rows, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        parentId = await resolveOptionalNodeId(client, parentId);
+        const database = await client.createDatabase(ws, {
+          name,
+          parentId,
+          path,
+          createParents,
+          icon,
+          properties,
+          views,
+          rows,
+        });
+        return jsonResult(database);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_update_view',
+    {
+      title: 'Edit a database view (hide columns, rename, regroup)',
+      description:
+        'Change ONE view of a Rootr (루터) DATABASE. Use `hiddenProps` to choose which columns that view shows — ' +
+        'the same table can look different per view (a "담당자" view hiding the amounts, etc). Hiding a column ' +
+        'does NOT erase its values: it disappears from that view only and comes back when you unhide it. ' +
+        'Columns may be given by NAME or id; the title column cannot be hidden and is ignored if listed. ' +
+        'Pass an empty array to show everything again. Only the fields you pass change, and other views are untouched.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        viewId: z.string().describe('View id or view NAME (from rootr_read_database)'),
+        hiddenProps: z
+          .array(z.string())
+          .optional()
+          .describe('Columns to hide in this view, by name or id. [] shows every column again.'),
+        name: z.string().optional().describe('New view name'),
+        groupBy: z.string().optional().describe('board view: the select column to group by (name or id)'),
+        dateProp: z.string().optional().describe('calendar/timeline view: the date column (name or id)'),
+        endDateProp: z.string().optional().describe('timeline view: the end-date column (name or id)'),
+      },
+    },
+    async ({ databaseId, viewId, hiddenProps, name, groupBy, dateProp, endDateProp }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        const view = await client.updateDatabaseView(id, viewId, {
+          hiddenProps,
+          name,
+          groupBy,
+          dateProp,
+          endDateProp,
+        });
+        return jsonResult({ view });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   server.registerTool(
     'rootr_read_database',
     {
@@ -44,15 +173,19 @@ export function registerDatabaseTools(server) {
       annotations: { readOnlyHint: true, destructiveHint: false },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        includeBody: z
+          .boolean()
+          .optional()
+          .describe("true → also return each row's detail body (the note under a card). Off by default."),
       },
     },
-    async ({ databaseId }) => {
+    async ({ databaseId, includeBody }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
         const [database, rows] = await Promise.all([
           client.getDatabase(id),
-          client.listRows(id),
+          client.listRows(id, { withBody: includeBody === true }),
         ]);
         return jsonResult({ database, rows });
       } catch (err) {
@@ -71,12 +204,18 @@ export function registerDatabaseTools(server) {
       annotations: { readOnlyHint: true, destructiveHint: false },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        includeBody: z
+          .boolean()
+          .optional()
+          .describe("true → also return each row's detail body (the note under a card). Off by default."),
       },
     },
-    async ({ databaseId }) => {
+    async ({ databaseId, includeBody }) => {
       try {
         const client = makeClient();
-        const rows = await client.listRows(await resolveNodeId(client, databaseId));
+        const rows = await client.listRows(await resolveNodeId(client, databaseId), {
+          withBody: includeBody === true,
+        });
         return jsonResult({ rows });
       } catch (err) {
         return errorResult(err);
@@ -92,21 +231,24 @@ export function registerDatabaseTools(server) {
         '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.',
+        'Call rootr_read_database first to learn the columns. Optionally set `position` to insert at an index. ' +
+        'Pass `body` to also write the row\'s DETAIL PAGE (the note shown under a kanban card\'s properties) — ' +
+        'that page is created on demand, so a row with `body` is the one-call equivalent of "메모 추가".',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),
         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'),
+        body: z.string().optional().describe(BODY_DESC),
       },
     },
-    async ({ databaseId, values, position }) => {
+    async ({ databaseId, values, position, body }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
         const database = await client.getDatabase(id);
         const resolved = resolveValueKeys(database.properties || [], values);
-        const row = await client.createRow(id, { values: resolved, position });
+        const row = await client.createRow(id, { values: resolved, position, body });
         return jsonResult(row);
       } catch (err) {
         return errorResult(err);
@@ -129,9 +271,10 @@ export function registerDatabaseTools(server) {
         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'),
+        body: z.string().optional().describe(BODY_DESC),
       },
     },
-    async ({ databaseId, rowId, values, position }) => {
+    async ({ databaseId, rowId, values, position, body }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
@@ -140,7 +283,7 @@ export function registerDatabaseTools(server) {
           const database = await client.getDatabase(id);
           resolved = resolveValueKeys(database.properties || [], values);
         }
-        const row = await client.updateRow(id, rowId, { values: resolved, position });
+        const row = await client.updateRow(id, rowId, { values: resolved, position, body });
         return jsonResult(row);
       } catch (err) {
         return errorResult(err);

package/lib/mcp-tools/templates.js

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+
+import {
+  jsonResult,
+  errorResult,
+  makeClient,
+  requireWorkspace,
+  resolveNodeId,
+  resolveOptionalNodeId,
+  NODE_TARGET_HINT,
+} from './shared.js';
+
+/**
+ * 문서 양식(템플릿) 도구.
+ *
+ * REST와 인앱 어시스턴트에는 예전부터 있었는데 MCP·CLI에만 없었다. 그래서 밖에서
+ * 붙은 에이전트(Claude 등)는 워크스페이스에 쓸 만한 양식이 이미 있는 줄도 모르고
+ * 매번 맨바닥부터 문서를 지어냈다 — 2026-08-18 점검에서 드러난 구멍이다.
+ *
+ * 양식은 세 종류다: `document`(마크다운 한 장), `database`(컬럼·뷰가 짜인 표),
+ * `tree`(폴더+문서+표가 얽힌 묶음). 빌트인 양식과 워크스페이스가 직접 만든 양식이
+ * 같은 목록에 함께 나온다.
+ */
+export function registerTemplateTools(server) {
+  server.registerTool(
+    'rootr_list_templates',
+    {
+      title: 'List document/database templates',
+      description:
+        'List the templates available in a Rootr (루터) workspace — builtins plus anything this workspace saved. ' +
+        'Each has an id, name, emoji, description and `kind` (document | database | tree). ' +
+        '**Call this before building a document or table from scratch**: if a fitting template exists, ' +
+        'rootr_apply_template gives the team their own agreed format instead of a shape you invented.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        return jsonResult(await makeClient(ws).listTemplates(ws));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_apply_template',
+    {
+      title: 'Create a node from a template',
+      description:
+        'Instantiate a Rootr (루터) template — creates the real node(s) it describes and returns the created node. ' +
+        'A `document` template makes one document, `database` makes a table with its columns and views already set, ' +
+        '`tree` makes a whole folder/document/table structure. Get ids from rootr_list_templates.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        templateId: z.string().describe('Template id from rootr_list_templates'),
+        parentId: z
+          .string()
+          .optional()
+          .describe(`Parent folder id${NODE_TARGET_HINT}; workspace root if omitted`),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ templateId, parentId, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        parentId = await resolveOptionalNodeId(client, parentId);
+        return jsonResult(await client.applyTemplate(ws, templateId, { parentId }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_save_as_template',
+    {
+      title: 'Save a node (or an inline spec) as a template',
+      description:
+        'Turn something into a reusable Rootr (루터) template. Either pass `nodeId` to capture an existing ' +
+        'document/table/folder as-is, or pass `kind` + `spec` to define one inline. Use this when the user says ' +
+        '"make this the standard format" or asks for a new form/양식. ' +
+        'NOTE: a template is workspace-wide and readable by every member — do not capture a restricted node ' +
+        'unless the user means to share its content with the whole workspace.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        name: z.string().describe('Template name, e.g. "주간 보고서 양식"'),
+        nodeId: z
+          .string()
+          .optional()
+          .describe(`Capture this existing node${NODE_TARGET_HINT}. Omit when passing kind+spec instead.`),
+        kind: z
+          .enum(['document', 'database', 'tree'])
+          .optional()
+          .describe('Inline definition: document (markdown) | database (columns+views) | tree (structure)'),
+        spec: z
+          .record(z.unknown())
+          .optional()
+          .describe('Inline definition body, matching `kind`. Ignored when nodeId is given.'),
+        emoji: z.string().optional().describe('Emoji shown in the template gallery'),
+        description: z.string().optional().describe('One line on when to use it'),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ name, nodeId, kind, spec, emoji, description, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        if (nodeId) {
+          const id = await resolveNodeId(client, nodeId);
+          return jsonResult(await client.saveTemplateFromNode(ws, id, { name, emoji, description }));
+        }
+        if (!kind || !spec) {
+          throw new Error('Pass either nodeId, or both kind and spec.');
+        }
+        return jsonResult(await client.createTemplate(ws, { name, emoji, description, kind, spec }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_update_template',
+    {
+      title: 'Edit a template',
+      description:
+        'Change a Rootr (루터) template — its name, emoji, description or `spec`. Editing a builtin transparently ' +
+        'creates a workspace copy, so the builtin itself is never damaged. Use this for "change the standard format" ' +
+        'requests instead of saving a second near-identical template.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        templateId: z.string().describe('Template id from rootr_list_templates'),
+        name: z.string().optional().describe('New name'),
+        emoji: z.string().optional().describe('New emoji'),
+        description: z.string().optional().describe('New one-line description'),
+        spec: z.record(z.unknown()).optional().describe('Replacement body, matching the template kind'),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ templateId, name, emoji, description, spec, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        return jsonResult(
+          await makeClient(ws).updateTemplate(ws, templateId, { name, emoji, description, spec }),
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}

package/lib/mcp.js

@@ -7,6 +7,7 @@ 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 { registerTemplateTools } from './mcp-tools/templates.js';
 import { registerWebhookTools } from './mcp-tools/webhooks.js';
 import { registerMiscTools } from './mcp-tools/misc.js';
 import { registerCrmTools } from './mcp-tools/crm.js';
@@ -122,6 +123,7 @@ export function buildMcpServer({ name, version }) {
   withQuotaWarnings(server);
 
   registerDocumentTools(server);
+  registerTemplateTools(server);
   registerWorkspaceTools(server);
   registerLogTools(server);
   registerAskTools(server);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.7.1",
+  "version": "0.8.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": {