synabun 1.3.0

package/mcp-server/src/tools/category.ts

@@ -0,0 +1,379 @@
+import { z } from 'zod';
+import {
+  validateCategoryName,
+  addCategory,
+  getAllCategories,
+  getCategories,
+  categoryExists,
+  updateCategory,
+  removeCategory,
+  validateCategory,
+  getChildCategories,
+  getParentCategories,
+  getCategoryTree,
+} from '../services/categories.js';
+import { countMemories, updatePayloadByFilter } from '../services/sqlite.js';
+import { refreshCategorySchemas } from '../index.js';
+import { text } from './response.js';
+
+export const categorySchema = {
+  action: z
+    .enum(['create', 'update', 'delete', 'list'] as const)
+    .describe('Action to perform: create, update, delete, or list categories.'),
+  name: z
+    .string()
+    .optional()
+    .describe('Category name (required for create/update/delete).'),
+  description: z
+    .string()
+    .optional()
+    .describe('Category description (required for create, optional for update).'),
+  is_parent: z
+    .boolean()
+    .optional()
+    .describe('Make this a parent/cluster category (create only).'),
+  parent: z
+    .string()
+    .optional()
+    .describe('Parent category name. Empty string "" to remove parent.'),
+  color: z
+    .string()
+    .optional()
+    .describe('Color hex code, e.g. "#3b82f6". Empty string "" to remove.'),
+  new_name: z
+    .string()
+    .optional()
+    .describe('Rename category to this (update only).'),
+  reassign_to: z
+    .string()
+    .optional()
+    .describe('Reassign memories to this category before deleting (delete only).'),
+  reassign_children_to: z
+    .string()
+    .optional()
+    .describe('Reassign child categories to this parent when deleting a parent. Empty string "" for top-level (delete only).'),
+  format: z
+    .enum(['flat', 'tree', 'parents-only'] as const)
+    .optional()
+    .describe('Output format for list action: flat, tree (default), or parents-only.'),
+};
+
+export const categoryDescription =
+  'Manage memory categories. Actions: create, update, delete, list. Categories persist across sessions.';
+
+// ── Create ──────────────────────────────────────────────────────
+
+async function handleCreate(args: {
+  name?: string;
+  description?: string;
+  parent?: string;
+  color?: string;
+  is_parent?: boolean;
+}) {
+  if (!args.name) {
+    return text('name is required for create action.');
+  }
+  if (!args.description?.trim()) {
+    return text('description is required for create action.');
+  }
+
+  const nameCheck = validateCategoryName(args.name);
+  if (!nameCheck.valid) {
+    return text(nameCheck.error!);
+  }
+
+  if (args.color && !/^#[0-9a-f]{6}$/i.test(args.color)) {
+    return text('Invalid color format. Use hex format: #rrggbb (e.g., #3b82f6)');
+  }
+
+  addCategory(args.name, args.description.trim(), args.parent, args.color, args.is_parent);
+  refreshCategorySchemas();
+
+  const all = getAllCategories();
+  let msg = `Created category "${args.name}" (${args.description.trim()})`;
+  if (args.is_parent) msg += ` as a parent category`;
+  if (args.parent) msg += ` under "${args.parent}" cluster`;
+  if (args.color) msg += ` with color ${args.color}`;
+  msg += `.\n\nAll categories (${all.length}): ${all.join(', ')}`;
+
+  return text(msg);
+}
+
+// ── Update ──────────────────────────────────────────────────────
+
+async function handleUpdate(args: {
+  name?: string;
+  new_name?: string;
+  description?: string;
+  parent?: string;
+  color?: string;
+}) {
+  const { name, new_name, description, parent, color } = args;
+
+  if (!name) {
+    return text('name is required for update action.');
+  }
+
+  if (!categoryExists(name)) {
+    return text(`Category "${name}" does not exist. Available: ${getAllCategories().join(', ')}`);
+  }
+
+  if (new_name) {
+    const NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+    const MIN_LENGTH = 2;
+    const MAX_LENGTH = 30;
+
+    if (new_name.length < MIN_LENGTH || new_name.length > MAX_LENGTH) {
+      return text(`New category name must be ${MIN_LENGTH}-${MAX_LENGTH} characters. Got ${new_name.length}.`);
+    }
+    if (!NAME_PATTERN.test(new_name)) {
+      return text('New category name must match /^[a-z][a-z0-9-]*$/ (lowercase, starts with letter, only letters/digits/hyphens).');
+    }
+    if (new_name !== name && categoryExists(new_name)) {
+      return text(`Category "${new_name}" already exists.`);
+    }
+  }
+
+  if (parent !== undefined && parent !== '') {
+    if (parent === name) {
+      return text(`Cannot set category "${name}" as its own parent. This would create a circular reference.`);
+    }
+    if (!categoryExists(parent)) {
+      return text(`Parent category "${parent}" does not exist. Available: ${getAllCategories().join(', ')}`);
+    }
+    const categories = getCategories();
+    let currentParent = parent;
+    while (currentParent) {
+      if (currentParent === (new_name || name)) {
+        return text(`Cannot set parent to "${parent}": would create circular dependency.`);
+      }
+      const parentCat = categories.find(c => c.name === currentParent);
+      currentParent = parentCat?.parent || '';
+    }
+  }
+
+  if (color !== undefined && color !== '' && !/^#[0-9a-f]{6}$/i.test(color)) {
+    return text('Invalid color format. Use hex format: #rrggbb (e.g., #3b82f6) or empty string to remove.');
+  }
+
+  const children = getChildCategories(name);
+  const isBecomingChild = parent !== undefined && parent !== '';
+
+  let warningMsg = '';
+  if (children.length > 0 && isBecomingChild) {
+    warningMsg = `\n\nWarning: This category has ${children.length} child categor${children.length === 1 ? 'y' : 'ies'} (${children.map(c => c.name).join(', ')}). Making it a child category will create nested levels.`;
+  }
+
+  const updates: {
+    new_name?: string;
+    description?: string;
+    parent?: string | null;
+    color?: string | null;
+  } = {};
+
+  if (new_name !== undefined) updates.new_name = new_name;
+  if (description !== undefined) updates.description = description;
+  if (parent !== undefined) updates.parent = parent === '' ? null : parent;
+  if (color !== undefined) updates.color = color === '' ? null : color;
+
+  updateCategory(name, updates);
+  refreshCategorySchemas();
+
+  const all = getAllCategories();
+  let msg = `Updated category "${name}"`;
+  if (new_name) msg += ` → "${new_name}"`;
+  msg += ':';
+
+  const changes: string[] = [];
+  if (description !== undefined) changes.push(`description: "${description}"`);
+  if (parent !== undefined) changes.push(`parent: ${parent === '' ? 'none (top-level)' : `"${parent}"`}`);
+  if (color !== undefined) changes.push(`color: ${color === '' ? 'auto-assigned' : color}`);
+
+  if (changes.length > 0) {
+    msg += '\n  ' + changes.join('\n  ');
+  }
+
+  msg += warningMsg;
+  msg += `\n\nAll categories (${all.length}): ${all.join(', ')}`;
+
+  return text(msg);
+}
+
+// ── Delete ──────────────────────────────────────────────────────
+
+async function handleDelete(args: {
+  name?: string;
+  reassign_to?: string;
+  reassign_children_to?: string;
+}) {
+  const { name, reassign_to, reassign_children_to } = args;
+
+  if (!name) {
+    return text('name is required for delete action.');
+  }
+
+  if (!categoryExists(name)) {
+    return text(`Category "${name}" does not exist. Available: ${getAllCategories().join(', ')}`);
+  }
+
+  if (reassign_to) {
+    const targetCheck = validateCategory(reassign_to);
+    if (!targetCheck.valid) {
+      return text(`Invalid reassign target: ${targetCheck.error}`);
+    }
+    if (reassign_to === name) {
+      return text('Cannot reassign to the same category being deleted.');
+    }
+  }
+
+  const children = getChildCategories(name);
+  if (children.length > 0 && reassign_children_to === undefined) {
+    return text(
+      `Cannot delete parent category "${name}": it has ${children.length} child categor${children.length === 1 ? 'y' : 'ies'} (${children.map(c => c.name).join(', ')}).\n\nProvide reassign_children_to to specify a new parent for them, or use empty string "" to make them top-level categories.`
+    );
+  }
+
+  if (reassign_children_to !== undefined && reassign_children_to !== '' && !categoryExists(reassign_children_to)) {
+    return text(`Invalid reassign_children_to: category "${reassign_children_to}" does not exist.`);
+  }
+
+  const memoryCount = await countMemories({
+    must: [{ key: 'category', match: { value: name } }],
+  });
+
+  if (memoryCount > 0 && !reassign_to) {
+    return text(
+      `Cannot delete category "${name}": ${memoryCount} memories use it. Provide reassign_to to move them to another category first.`
+    );
+  }
+
+  if (memoryCount > 0 && reassign_to) {
+    await updatePayloadByFilter(
+      { must: [{ key: 'category', match: { value: name } }] },
+      { category: reassign_to }
+    );
+  }
+
+  let childrenMsg = '';
+  if (children.length > 0) {
+    const newParent = reassign_children_to === '' ? null : reassign_children_to;
+    children.forEach((child) => {
+      updateCategory(child.name, { parent: newParent });
+    });
+
+    if (reassign_children_to === '') {
+      childrenMsg = ` ${children.length} child categor${children.length === 1 ? 'y' : 'ies'} made top-level.`;
+    } else {
+      childrenMsg = ` ${children.length} child categor${children.length === 1 ? 'y' : 'ies'} reassigned to "${reassign_children_to}".`;
+    }
+  }
+
+  removeCategory(name);
+  refreshCategorySchemas();
+
+  const all = getAllCategories();
+  const reassignMsg = memoryCount > 0
+    ? ` ${memoryCount} memories reassigned to "${reassign_to}".`
+    : '';
+
+  return text(`Deleted category "${name}".${reassignMsg}${childrenMsg}\n\nRemaining categories (${all.length}): ${all.join(', ')}`);
+}
+
+// ── List ────────────────────────────────────────────────────────
+
+async function handleList(args: { format?: 'flat' | 'tree' | 'parents-only' }) {
+  const format = args.format || 'tree';
+  const categories = getCategories();
+
+  if (format === 'flat') {
+    const lines = categories.map((cat) => {
+      let line = `- ${cat.name}: ${cat.description}`;
+      if (cat.parent) line += ` (parent: ${cat.parent})`;
+      if (cat.color) line += ` [${cat.color}]`;
+      return line;
+    });
+
+    return text(`All categories (${categories.length}):\n\n${lines.join('\n')}`);
+  }
+
+  if (format === 'parents-only') {
+    const parents = getParentCategories();
+    const lines = parents.map((cat) => {
+      const children = getChildCategories(cat.name);
+      let line = `- ${cat.name}: ${cat.description}`;
+      if (cat.color) line += ` [${cat.color}]`;
+      if (children.length > 0) {
+        line += ` (${children.length} children)`;
+      }
+      return line;
+    });
+
+    return text(`Parent categories (${parents.length}):\n\n${lines.join('\n')}`);
+  }
+
+  // Tree format (default)
+  const tree = getCategoryTree();
+  const parents = getParentCategories();
+  const lines: string[] = [];
+
+  parents.forEach((parent) => {
+    const children = tree[parent.name] || [];
+    let parentLine = `## ${parent.name}`;
+    if (parent.color) parentLine += ` [${parent.color}]`;
+    parentLine += `\n${parent.description}`;
+
+    lines.push(parentLine);
+
+    if (children.length > 0) {
+      children.forEach((child) => {
+        let childLine = `  - ${child.name}: ${child.description}`;
+        if (child.color) childLine += ` [${child.color}]`;
+        lines.push(childLine);
+      });
+    } else {
+      lines.push('  (no children)');
+    }
+
+    lines.push('');
+  });
+
+  const orphans = categories.filter((c) => !c.parent && !parents.find((p) => p.name === c.name));
+  if (orphans.length > 0) {
+    lines.push('## Uncategorized');
+    orphans.forEach((cat) => {
+      let line = `  - ${cat.name}: ${cat.description}`;
+      if (cat.color) line += ` [${cat.color}]`;
+      lines.push(line);
+    });
+  }
+
+  return text(`Category Tree (${categories.length} total, ${parents.length} parent clusters):\n\n${lines.join('\n')}`);
+}
+
+// ── Main dispatcher ─────────────────────────────────────────────
+
+export async function handleCategory(args: {
+  action: string;
+  name?: string;
+  description?: string;
+  is_parent?: boolean;
+  parent?: string;
+  color?: string;
+  new_name?: string;
+  reassign_to?: string;
+  reassign_children_to?: string;
+  format?: string;
+}) {
+  switch (args.action) {
+    case 'create':
+      return handleCreate(args);
+    case 'update':
+      return handleUpdate(args);
+    case 'delete':
+      return handleDelete(args);
+    case 'list':
+      return handleList(args as { format?: 'flat' | 'tree' | 'parents-only' });
+    default:
+      return text(`Unknown action "${args.action}". Use: create, update, delete, list.`);
+  }
+}

package/mcp-server/src/tools/discord-channel.ts

@@ -0,0 +1,274 @@
+import { z } from 'zod';
+import * as discord from '../services/discord.js';
+import { text } from './response.js';
+
+export const discordChannelSchema = {
+  action: z.enum(['create', 'edit', 'delete', 'list', 'permissions'] as const)
+    .describe('Action: create, edit, delete, list, or permissions.'),
+  guild_id: z.string().optional()
+    .describe('Guild ID. Defaults to DISCORD_GUILD_ID env var.'),
+  channel: z.string().optional()
+    .describe('Channel name or ID (required for edit/delete/permissions).'),
+  name: z.string().optional()
+    .describe('Channel name (create required, edit optional).'),
+  type: z.enum(['text', 'voice', 'category', 'announcement', 'forum', 'stage'] as const).optional()
+    .describe('Channel type (create only, default: text). Use "category" for channel categories.'),
+  topic: z.string().optional()
+    .describe('Channel topic/description (create/edit).'),
+  parent: z.string().optional()
+    .describe('Parent category name or ID (create/edit). Empty string to remove.'),
+  position: z.number().optional()
+    .describe('Sort position (create/edit).'),
+  nsfw: z.boolean().optional()
+    .describe('NSFW flag (create/edit).'),
+  slowmode: z.number().optional()
+    .describe('Slowmode in seconds, 0-21600 (create/edit).'),
+  bitrate: z.number().optional()
+    .describe('Voice bitrate in bps (voice channels, create/edit).'),
+  user_limit: z.number().optional()
+    .describe('Voice user limit, 0=unlimited (voice channels, create/edit).'),
+  target: z.string().optional()
+    .describe('Role or user name/ID (permissions action). Use "type:role" or "type:user" prefix, or bare name/ID.'),
+  allow: z.string().optional()
+    .describe('Permission flags to allow, comma-separated (permissions). E.g. "SEND_MESSAGES,VIEW_CHANNEL".'),
+  deny: z.string().optional()
+    .describe('Permission flags to deny, comma-separated (permissions). E.g. "SEND_MESSAGES".'),
+  reason: z.string().optional()
+    .describe('Audit log reason.'),
+};
+
+export const discordChannelDescription =
+  'Discord channel management. Actions: create, edit, delete, list, permissions. Handles text, voice, categories, forums, stages.';
+
+// ── Create ─────────────────────────────────────────────────────
+
+async function handleCreate(guildId: string, args: {
+  name?: string; type?: string; topic?: string; parent?: string;
+  position?: number; nsfw?: boolean; slowmode?: number;
+  bitrate?: number; user_limit?: number; reason?: string;
+}) {
+  if (!args.name) {
+    return text('name is required for create action.');
+  }
+
+  const channelType = args.type ? discord.CHANNEL_TYPES[args.type] : 0;
+  if (channelType === undefined) {
+    return text(`Unknown channel type "${args.type}". Use: text, voice, category, announcement, forum, stage.`);
+  }
+
+  const data: Record<string, unknown> = {
+    name: args.name,
+    type: channelType,
+  };
+
+  if (args.topic !== undefined) data.topic = args.topic;
+  if (args.position !== undefined) data.position = args.position;
+  if (args.nsfw !== undefined) data.nsfw = args.nsfw;
+  if (args.slowmode !== undefined) data.rate_limit_per_user = args.slowmode;
+  if (args.bitrate !== undefined) data.bitrate = args.bitrate;
+  if (args.user_limit !== undefined) data.user_limit = args.user_limit;
+
+  // Resolve parent category
+  if (args.parent) {
+    const parentResolved = await discord.resolveChannel(args.parent, guildId);
+    if ('error' in parentResolved) return text(`Parent category: ${parentResolved.error}`);
+    data.parent_id = parentResolved.id;
+  }
+
+  const res = await discord.createChannel(guildId, data);
+  if (res.error) return text(res.error);
+
+  const ch = res.data as { id: string; name: string; type: number };
+  const typeName = discord.CHANNEL_TYPE_NAMES[ch.type] || 'unknown';
+  return text(`Created ${typeName} channel #${ch.name} (${ch.id})${args.topic ? ` — "${args.topic}"` : ''}`);
+}
+
+// ── Edit ───────────────────────────────────────────────────────
+
+async function handleEdit(guildId: string, args: {
+  channel?: string; name?: string; topic?: string; parent?: string;
+  position?: number; nsfw?: boolean; slowmode?: number;
+  bitrate?: number; user_limit?: number; reason?: string;
+}) {
+  if (!args.channel) {
+    return text('channel is required for edit action.');
+  }
+
+  const resolved = await discord.resolveChannel(args.channel, guildId);
+  if ('error' in resolved) return text(resolved.error);
+
+  const data: Record<string, unknown> = {};
+  if (args.name !== undefined) data.name = args.name;
+  if (args.topic !== undefined) data.topic = args.topic;
+  if (args.position !== undefined) data.position = args.position;
+  if (args.nsfw !== undefined) data.nsfw = args.nsfw;
+  if (args.slowmode !== undefined) data.rate_limit_per_user = args.slowmode;
+  if (args.bitrate !== undefined) data.bitrate = args.bitrate;
+  if (args.user_limit !== undefined) data.user_limit = args.user_limit;
+
+  if (args.parent !== undefined) {
+    if (args.parent === '') {
+      data.parent_id = null;
+    } else {
+      const parentResolved = await discord.resolveChannel(args.parent, guildId);
+      if ('error' in parentResolved) return text(`Parent category: ${parentResolved.error}`);
+      data.parent_id = parentResolved.id;
+    }
+  }
+
+  if (Object.keys(data).length === 0) {
+    return text('No changes specified. Provide at least one field to update.');
+  }
+
+  const res = await discord.editChannel(resolved.id, data);
+  if (res.error) return text(res.error);
+
+  const changes = Object.entries(data).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(', ');
+  return text(`Updated #${resolved.name} (${resolved.id}): ${changes}`);
+}
+
+// ── Delete ─────────────────────────────────────────────────────
+
+async function handleDelete(guildId: string, args: { channel?: string; reason?: string }) {
+  if (!args.channel) {
+    return text('channel is required for delete action.');
+  }
+
+  const resolved = await discord.resolveChannel(args.channel, guildId);
+  if ('error' in resolved) return text(resolved.error);
+
+  const res = await discord.deleteChannel(resolved.id);
+  if (res.error) return text(res.error);
+
+  return text(`Deleted channel #${resolved.name} (${resolved.id}).`);
+}
+
+// ── List ───────────────────────────────────────────────────────
+
+async function handleList(guildId: string) {
+  const channels = await discord.getGuildChannels(guildId);
+  if ('error' in channels) return text((channels as { error: string }).error);
+
+  const list = channels as { id: string; name: string; type: number; parent_id?: string; position: number; topic?: string }[];
+  const categories = list.filter(c => c.type === 4).sort((a, b) => a.position - b.position);
+  const uncategorized = list.filter(c => c.type !== 4 && !c.parent_id).sort((a, b) => a.position - b.position);
+
+  const lines: string[] = [];
+
+  if (uncategorized.length > 0) {
+    lines.push('**No Category:**');
+    for (const ch of uncategorized) {
+      const typeName = discord.CHANNEL_TYPE_NAMES[ch.type] || 'unknown';
+      lines.push(`  #${ch.name} (${typeName}, ${ch.id})${ch.topic ? ` — ${ch.topic}` : ''}`);
+    }
+    lines.push('');
+  }
+
+  for (const cat of categories) {
+    const children = list.filter(c => c.parent_id === cat.id).sort((a, b) => a.position - b.position);
+    lines.push(`**${cat.name}** (category, ${cat.id})`);
+    for (const ch of children) {
+      const typeName = discord.CHANNEL_TYPE_NAMES[ch.type] || 'unknown';
+      lines.push(`  #${ch.name} (${typeName}, ${ch.id})${ch.topic ? ` — ${ch.topic}` : ''}`);
+    }
+    if (children.length === 0) lines.push('  (empty)');
+    lines.push('');
+  }
+
+  return text(`Channels (${list.length}):\n\n${lines.join('\n')}`);
+}
+
+// ── Permissions ────────────────────────────────────────────────
+
+async function handlePermissions(guildId: string, args: {
+  channel?: string; target?: string; allow?: string; deny?: string;
+}) {
+  if (!args.channel) {
+    return text('channel is required for permissions action.');
+  }
+  if (!args.target) {
+    return text('target (role or user name/ID) is required for permissions action.');
+  }
+
+  const channelResolved = await discord.resolveChannel(args.channel, guildId);
+  if ('error' in channelResolved) return text(channelResolved.error);
+
+  // Determine if target is a role (type 0) or member (type 1)
+  // Try role first, then user
+  let targetId: string;
+  let targetType: number;
+  let targetName: string;
+
+  const roleResolved = await discord.resolveRole(args.target, guildId);
+  if (!('error' in roleResolved)) {
+    targetId = roleResolved.id;
+    targetType = 0; // role
+    targetName = `@${roleResolved.name}`;
+  } else {
+    const userResolved = await discord.resolveUser(args.target, guildId);
+    if ('error' in userResolved) {
+      return text(`Could not resolve target "${args.target}" as a role or user.`);
+    }
+    targetId = userResolved.id;
+    targetType = 1; // member
+    targetName = userResolved.name;
+  }
+
+  let allowBits = '0';
+  let denyBits = '0';
+
+  try {
+    if (args.allow) allowBits = discord.resolvePermissions(args.allow);
+    if (args.deny) denyBits = discord.resolvePermissions(args.deny);
+  } catch (err) {
+    return text((err as Error).message);
+  }
+
+  const res = await discord.setChannelPermissions(channelResolved.id, targetId, {
+    type: targetType,
+    allow: allowBits,
+    deny: denyBits,
+  });
+  if (res.error) return text(res.error);
+
+  const parts: string[] = [];
+  if (args.allow) parts.push(`allow: ${args.allow}`);
+  if (args.deny) parts.push(`deny: ${args.deny}`);
+
+  return text(`Set permissions on #${channelResolved.name} for ${targetName}: ${parts.join(', ')}`);
+}
+
+// ── Main dispatcher ────────────────────────────────────────────
+
+export async function handleDiscordChannel(args: {
+  action: string;
+  guild_id?: string;
+  channel?: string;
+  name?: string;
+  type?: string;
+  topic?: string;
+  parent?: string;
+  position?: number;
+  nsfw?: boolean;
+  slowmode?: number;
+  bitrate?: number;
+  user_limit?: number;
+  target?: string;
+  allow?: string;
+  deny?: string;
+  reason?: string;
+}) {
+  const resolved = await discord.resolveGuildId(args.guild_id);
+  if ('error' in resolved) return text(resolved.error);
+  const guildId = resolved.guildId;
+
+  switch (args.action) {
+    case 'create': return handleCreate(guildId, args);
+    case 'edit': return handleEdit(guildId, args);
+    case 'delete': return handleDelete(guildId, args);
+    case 'list': return handleList(guildId);
+    case 'permissions': return handlePermissions(guildId, args);
+    default:
+      return text(`Unknown action "${args.action}". Use: create, edit, delete, list, permissions.`);
+  }
+}