@gwdn/nexus-mcp 0.8.7 → 0.8.9

package/src/tools/letters.ts

@@ -1,144 +0,0 @@
-/**
- * vl_create + vl_reply -- Layer 2 Coordination
- *
- * Vault letter management for agent coordination.
- * Delegates to POST /api/mcp/letters (actions: vl_create, vl_reply).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-// ---------------------------------------------------------------------------
-// create_letter
-// ---------------------------------------------------------------------------
-
-export const createLetterSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-  from_actor: z.string().max(200).describe('Sender identifier (agent name or user)'),
-  to_actor: z.string().max(200).describe('Recipient identifier (agent name or user)'),
-  subject: z.string().max(500).describe('Letter subject'),
-  body: z.string().max(100_000).describe('Initial message body'),
-  priority: z
-    .enum(['low', 'normal', 'high', 'urgent'])
-    .default('normal')
-    .describe('Letter priority'),
-  blocking: z
-    .boolean()
-    .default(false)
-    .describe('Whether this letter blocks the sender'),
-  thread_id: z
-    .string()
-    .uuid()
-    .optional()
-    .describe('Optional thread UUID to group related letters'),
-  agent_id: z.string().max(200).optional().describe('Agent identifier if applicable'),
-}
-
-type CreateLetterArgs = {
-  project_id: string
-  from_actor: string
-  to_actor: string
-  subject: string
-  body: string
-  priority?: string
-  blocking?: boolean
-  thread_id?: string
-  user_id: string
-  agent_id?: string
-}
-
-export async function createLetter(args: CreateLetterArgs) {
-  const result = await nexusPost('/api/mcp/letters', {
-    action: 'vl_create',
-    project_id: args.project_id,
-    from_actor: args.from_actor,
-    to_actor: args.to_actor,
-    subject: args.subject,
-    body: args.body,
-    priority: args.priority ?? 'normal',
-    blocking: args.blocking ?? false,
-    thread_id: args.thread_id,
-    agent_id: args.agent_id,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// reply_letter
-// ---------------------------------------------------------------------------
-
-export const replyLetterSchema = {
-  letter_id: z.string().uuid().describe('Letter UUID to reply to'),
-  body: z.string().max(100_000).describe('Reply message body'),
-  message_type: z
-    .enum(['response', 'clarification', 'review_note', 'follow_up', 'context'])
-    .default('response')
-    .describe('Type of reply message'),
-  agent_id: z.string().max(200).optional().describe('Agent identifier if applicable'),
-  new_status: z
-    .enum([
-      'acknowledged',
-      'in_progress',
-      'answered',
-      'blocked',
-      'needs_review',
-      'closed',
-    ])
-    .optional()
-    .describe('Optionally update the letter status'),
-}
-
-type ReplyLetterArgs = {
-  letter_id: string
-  body: string
-  message_type?: string
-  user_id: string
-  agent_id?: string
-  new_status?: string
-}
-
-export async function replyLetter(args: ReplyLetterArgs) {
-  const result = await nexusPost('/api/mcp/letters', {
-    action: 'vl_reply',
-    letter_id: args.letter_id,
-    body: args.body,
-    message_type: args.message_type ?? 'response',
-    agent_id: args.agent_id,
-    new_status: args.new_status,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}

package/src/tools/list-documents.ts

@@ -1,58 +0,0 @@
-/**
- * doc_list -- Layer 2 Coordination
- *
- * List ingested documents for a project with optional source filtering.
- * Delegates to POST /api/mcp/documents (action: doc_list).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const listDocumentsSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-  source: z
-    .string()
-    .max(200)
-    .optional()
-    .describe('Filter by source (e.g., "mcp-agent", "research", "session-extract")'),
-  limit: z
-    .number()
-    .min(1)
-    .max(100)
-    .default(50)
-    .describe('Maximum number of documents to return (default 50)'),
-}
-
-type ListDocumentsArgs = {
-  project_id: string
-  source?: string
-  limit?: number
-  user_id: string
-}
-
-export async function listDocuments(args: ListDocumentsArgs) {
-  const result = await nexusPost('/api/mcp/documents', {
-    action: 'doc_list',
-    project_id: args.project_id,
-    source: args.source,
-    limit: args.limit ?? 50,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}

package/src/tools/list-tasks.ts

@@ -1,57 +0,0 @@
-/**
- * task_list -- Layer 2 Coordination
- *
- * List tasks for a project with optional status filtering.
- * Delegates to POST /api/mcp/tasks (action: task_list).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const listTasksSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-  status_filter: z
-    .array(z.enum(['open', 'in_progress', 'blocked', 'done', 'cancelled']))
-    .optional()
-    .describe('Filter by task status (default: all statuses)'),
-  limit: z
-    .number()
-    .min(1)
-    .max(100)
-    .default(50)
-    .describe('Maximum number of tasks to return (default 50)'),
-}
-
-type ListTasksArgs = {
-  project_id: string
-  status_filter?: string[]
-  limit?: number
-  user_id: string
-}
-
-export async function listTasks(args: ListTasksArgs) {
-  const result = await nexusPost('/api/mcp/tasks', {
-    action: 'task_list',
-    project_id: args.project_id,
-    status_filter: args.status_filter,
-    limit: args.limit ?? 50,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}

package/src/tools/project-list.ts

@@ -1,52 +0,0 @@
-/**
- * project_list -- Layer 1 Knowledge Access
- *
- * List accessible projects for the authenticated user/agent.
- * Delegates to GET /api/mcp/projects.
- */
-
-import { z } from 'zod'
-import { nexusGet } from '../nexus-api.js'
-
-export const projectListSchema = {
-  limit: z
-    .number()
-    .int()
-    .min(1)
-    .max(100)
-    .optional()
-    .describe('Maximum number of projects to return'),
-}
-
-type ProjectListArgs = {
-  limit?: number
-}
-
-export async function projectList(args: ProjectListArgs) {
-  const params = new URLSearchParams()
-  if (args.limit !== undefined) {
-    params.set('limit', String(args.limit))
-  }
-  const qs = params.toString()
-  const path = `/api/mcp/projects${qs ? `?${qs}` : ''}`
-
-  const result = await nexusGet(path)
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}

package/src/tools/reviews.ts

@@ -1,281 +0,0 @@
-/**
- * rv_list + rv_get + rv_create + rv_decide + rv_comment -- Layer 4 Reviews
- *
- * Review lifecycle management tools for the Nexus platform.
- * Reviews cover skills, agents, and other governed entities.
- * Delegates to POST /api/mcp/reviews.
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-// ---------------------------------------------------------------------------
-// rv_list
-// ---------------------------------------------------------------------------
-
-export const rvListSchema = {
-  entity_type: z
-    .enum(['skill', 'agent'])
-    .optional()
-    .describe('Filter by entity type (skill or agent)'),
-  status: z
-    .string()
-    .max(50)
-    .optional()
-    .describe('Filter by review status'),
-  limit: z
-    .number()
-    .int()
-    .min(1)
-    .max(100)
-    .optional()
-    .describe('Maximum number of reviews to return'),
-}
-
-type RvListArgs = {
-  entity_type?: string
-  status?: string
-  limit?: number
-  user_id: string
-}
-
-export async function rvList(args: RvListArgs) {
-  const result = await nexusPost('/api/mcp/reviews', {
-    action: 'rv_list',
-    entity_type: args.entity_type,
-    status: args.status,
-    limit: args.limit,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// rv_get
-// ---------------------------------------------------------------------------
-
-export const rvGetSchema = {
-  review_id: z
-    .string()
-    .uuid()
-    .optional()
-    .describe('Review UUID (look up by review ID)'),
-  entity_type: z
-    .string()
-    .max(50)
-    .optional()
-    .describe('Entity type (used with entity_id for lookup by entity)'),
-  entity_id: z
-    .string()
-    .uuid()
-    .optional()
-    .describe('Entity UUID (used with entity_type for lookup by entity)'),
-}
-
-type RvGetArgs = {
-  review_id?: string
-  entity_type?: string
-  entity_id?: string
-  user_id: string
-}
-
-export async function rvGet(args: RvGetArgs) {
-  const result = await nexusPost('/api/mcp/reviews', {
-    action: 'rv_get',
-    review_id: args.review_id,
-    entity_type: args.entity_type,
-    entity_id: args.entity_id,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// rv_create
-// ---------------------------------------------------------------------------
-
-export const rvCreateSchema = {
-  entity_type: z
-    .enum(['skill', 'agent'])
-    .describe('Type of entity to create a review for'),
-  entity_id: z
-    .string()
-    .uuid()
-    .describe('UUID of the entity to review'),
-}
-
-type RvCreateArgs = {
-  entity_type: string
-  entity_id: string
-  user_id: string
-}
-
-export async function rvCreate(args: RvCreateArgs) {
-  const result = await nexusPost('/api/mcp/reviews', {
-    action: 'rv_create',
-    entity_type: args.entity_type,
-    entity_id: args.entity_id,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// rv_decide
-// ---------------------------------------------------------------------------
-
-export const rvDecideSchema = {
-  review_id: z.string().uuid().describe('Review UUID'),
-  transition: z
-    .enum(['submit', 'accept', 'reject', 'request_revision', 'resubmit', 'archive'])
-    .describe('State transition to apply'),
-  rationale: z
-    .string()
-    .max(10_000)
-    .optional()
-    .describe('Optional rationale for the decision'),
-}
-
-type RvDecideArgs = {
-  review_id: string
-  transition: string
-  rationale?: string
-  user_id: string
-}
-
-export async function rvDecide(args: RvDecideArgs) {
-  const result = await nexusPost('/api/mcp/reviews', {
-    action: 'rv_decide',
-    review_id: args.review_id,
-    transition: args.transition,
-    rationale: args.rationale,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// rv_comment
-// ---------------------------------------------------------------------------
-
-export const rvCommentSchema = {
-  review_id: z.string().uuid().describe('Review UUID'),
-  body: z.string().max(100_000).describe('Comment body (markdown supported)'),
-  agent_id: z
-    .string()
-    .max(200)
-    .optional()
-    .describe('Agent identifier if comment is posted by an agent'),
-  line_start: z
-    .number()
-    .int()
-    .optional()
-    .describe('Start line number for inline comments'),
-  line_end: z
-    .number()
-    .int()
-    .optional()
-    .describe('End line number for inline comments'),
-}
-
-type RvCommentArgs = {
-  review_id: string
-  body: string
-  agent_id?: string
-  line_start?: number
-  line_end?: number
-  user_id: string
-}
-
-export async function rvComment(args: RvCommentArgs) {
-  const result = await nexusPost('/api/mcp/reviews', {
-    action: 'rv_comment',
-    review_id: args.review_id,
-    body: args.body,
-    agent_id: args.agent_id,
-    line_start: args.line_start,
-    line_end: args.line_end,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: result.error }, null, 2),
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(result.data, null, 2) },
-    ],
-  }
-}

package/src/tools/search-knowledge.ts

@@ -1,68 +0,0 @@
-/**
- * kb_search -- Layer 1 Knowledge Access
- *
- * Searches project knowledge using keyword, semantic, or hybrid mode.
- * Delegates to POST /api/mcp/search.
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const searchKnowledgeSchema = {
-  query: z.string().max(1000).describe('Free-text search query'),
-  project_id: z.string().uuid().describe('Project UUID to scope the search'),
-  entity_types: z
-    .array(
-      z.enum([
-        'session',
-        'decision',
-        'letter',
-        'task',
-        'research_note',
-        'planning_item',
-        'ingest_item',
-      ]),
-    )
-    .optional()
-    .describe('Filter to specific entity types'),
-  search_mode: z
-    .enum(['keyword', 'semantic', 'hybrid'])
-    .default('keyword')
-    .describe('Search mode: keyword, semantic, or hybrid'),
-  limit: z
-    .number()
-    .int()
-    .min(1)
-    .max(50)
-    .default(10)
-    .describe('Maximum results to return'),
-}
-
-type SearchArgs = {
-  query: string
-  project_id: string
-  entity_types?: string[]
-  search_mode?: string
-  limit?: number
-}
-
-export async function searchKnowledge(args: SearchArgs) {
-  const result = await nexusPost('/api/mcp/search', {
-    project_id: args.project_id,
-    query: args.query,
-    entity_types: args.entity_types,
-    search_mode: args.search_mode ?? 'keyword',
-    limit: args.limit ?? 10,
-  })
-
-  if (!result.ok) {
-    return {
-      content: [{ type: 'text' as const, text: JSON.stringify({ error: result.error }, null, 2) }],
-      isError: true,
-    }
-  }
-
-  return {
-    content: [{ type: 'text' as const, text: JSON.stringify(result.data, null, 2) }],
-  }
-}