@gwdn/nexus-mcp 0.8.6 → 0.8.8

package/src/tools/append-session-entry.ts

@@ -1,113 +0,0 @@
-/**
- * session_append -- Layer 2 Coordination
- *
- * Appends an entry to an existing session.
- * Enforces append-only semantics and session write isolation.
- * Delegates to POST /api/mcp/sessions (action: session_append).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const appendSessionEntrySchema = {
-  session_id: z.string().uuid().describe('Session UUID to append to'),
-  entry_type: z
-    .enum([
-      'decision_referenced',
-      'task_created',
-      'task_updated',
-      'letter_sent',
-      'letter_replied',
-      'research_added',
-      'conflict_detected',
-      'adr_drafted',
-      'adr_accepted',
-      'handoff_recorded',
-      'note',
-      'correction',
-      'security_scan',
-      'performance_scan',
-    ])
-    .describe('Type of session entry'),
-  summary: z.string().max(100_000).describe('Entry content / summary text'),
-  linked_entity_type: z
-    .string()
-    .max(50)
-    .optional()
-    .describe(
-      'Type of linked entity (e.g., "task", "decision", "letter", "research_link")',
-    ),
-  linked_entity_id: z
-    .string()
-    .uuid()
-    .optional()
-    .describe('UUID of the linked entity'),
-  agent_id: z.string().max(200).optional().describe('Agent identifier if applicable'),
-  metadata: z
-    .string()
-    .max(10_000)
-    .optional()
-    .describe(
-      'JSON string of metadata to merge into the session entry. ' +
-        'Example: \'{"model": "claude-opus-4", "toolstack": "opencode", "machine_id": "..."}\'',
-    ),
-}
-
-type AppendSessionEntryArgs = {
-  session_id: string
-  entry_type: string
-  summary: string
-  linked_entity_type?: string
-  linked_entity_id?: string
-  user_id: string
-  agent_id?: string
-  metadata?: string
-}
-
-export async function appendSessionEntry(args: AppendSessionEntryArgs) {
-  let parsedMetadata: Record<string, unknown> | undefined
-  if (args.metadata) {
-    try {
-      parsedMetadata = JSON.parse(args.metadata)
-    } catch {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: JSON.stringify({ error: 'metadata must be a valid JSON string' }, null, 2),
-          },
-        ],
-        isError: true,
-      }
-    }
-  }
-
-  const result = await nexusPost('/api/mcp/sessions', {
-    action: 'session_append',
-    session_id: args.session_id,
-    entry_type: args.entry_type,
-    summary: args.summary,
-    agent_id: args.agent_id,
-    linked_entity_type: args.linked_entity_type,
-    linked_entity_id: args.linked_entity_id,
-    ...(parsedMetadata ? { metadata: parsedMetadata } : {}),
-  })
-
-  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/classify-document.ts

@@ -1,55 +0,0 @@
-/**
- * doc_classify -- Layer 2 Coordination
- *
- * Update the classification of an ingest item.
- * Delegates to POST /api/mcp/documents (action: doc_classify).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const classifyDocumentSchema = {
-  document_id: z.string().uuid().describe('Document UUID to classify'),
-  classification: z
-    .enum([
-      'unclassified',
-      'research_note',
-      'planning_item',
-      'decision_input',
-      'reference',
-      'archive',
-    ])
-    .describe('New classification for the document'),
-}
-
-type ClassifyDocumentArgs = {
-  document_id: string
-  classification: string
-  user_id: string
-}
-
-export async function classifyDocument(args: ClassifyDocumentArgs) {
-  const result = await nexusPost('/api/mcp/documents', {
-    action: 'doc_classify',
-    document_id: args.document_id,
-    classification: args.classification,
-  })
-
-  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/create-task.ts

@@ -1,66 +0,0 @@
-/**
- * task_create -- Layer 2 Coordination
- *
- * Creates a new task within a project scope.
- * Delegates to POST /api/mcp/tasks (action: task_create).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const createTaskSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-  title: z.string().max(500).describe('Task title'),
-  description: z.string().max(100_000).optional().describe('Task description'),
-  priority: z
-    .enum(['low', 'normal', 'high', 'urgent'])
-    .default('normal')
-    .describe('Task priority'),
-  assignee: z.string().uuid().optional().describe('UUID of the assigned user'),
-  status: z
-    .enum(['open', 'in_progress', 'blocked', 'done', 'cancelled'])
-    .default('open')
-    .describe('Initial task status'),
-  agent_id: z.string().max(200).optional().describe('Agent identifier if applicable'),
-}
-
-type CreateTaskArgs = {
-  project_id: string
-  title: string
-  description?: string
-  priority?: string
-  assignee?: string
-  status?: string
-  user_id: string
-  agent_id?: string
-}
-
-export async function createTask(args: CreateTaskArgs) {
-  const result = await nexusPost('/api/mcp/tasks', {
-    action: 'task_create',
-    project_id: args.project_id,
-    title: args.title,
-    description: args.description,
-    priority: args.priority ?? 'normal',
-    assignee: args.assignee,
-    status: args.status ?? 'open',
-  })
-
-  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/decision-comments.ts

@@ -1,103 +0,0 @@
-/**
- * Decision comment tools -- Layer 2 Coordination
- *
- * Provides append-only comment threads for ADR decisions.
- * Delegates to POST /api/mcp/governance (actions: dc_add, dc_list).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-// ---------------------------------------------------------------------------
-// add_decision_comment -> dc_add
-// ---------------------------------------------------------------------------
-
-export const addDecisionCommentSchema = {
-  decision_id: z.string().uuid().describe('Decision UUID to comment on'),
-  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'),
-}
-
-type AddDecisionCommentArgs = {
-  decision_id: string
-  body: string
-  agent_id?: string
-  user_id: string
-}
-
-export async function addDecisionComment(args: AddDecisionCommentArgs) {
-  const result = await nexusPost('/api/mcp/governance', {
-    action: 'dc_add',
-    decision_id: args.decision_id,
-    body: args.body,
-    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) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// list_decision_comments -> dc_list
-// ---------------------------------------------------------------------------
-
-export const listDecisionCommentsSchema = {
-  decision_id: z.string().uuid().describe('Decision UUID'),
-  limit: z
-    .number()
-    .int()
-    .min(1)
-    .max(100)
-    .default(50)
-    .describe('Maximum comments to return'),
-}
-
-type ListDecisionCommentsArgs = {
-  decision_id: string
-  limit?: number
-}
-
-export async function listDecisionComments(args: ListDecisionCommentsArgs) {
-  const result = await nexusPost('/api/mcp/governance', {
-    action: 'dc_list',
-    decision_id: args.decision_id,
-    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/delete-document.ts

@@ -1,43 +0,0 @@
-/**
- * doc_delete -- Layer 2 Coordination
- *
- * Delete an ingest item from a project's knowledge base.
- * Delegates to POST /api/mcp/documents (action: doc_delete).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const deleteDocumentSchema = {
-  document_id: z.string().uuid().describe('Document UUID to delete'),
-}
-
-type DeleteDocumentArgs = {
-  document_id: string
-  user_id: string
-}
-
-export async function deleteDocument(args: DeleteDocumentArgs) {
-  const result = await nexusPost('/api/mcp/documents', {
-    action: 'doc_delete',
-    document_id: args.document_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) },
-    ],
-  }
-}

package/src/tools/directives.ts

@@ -1,303 +0,0 @@
-/**
- * pd_list + pd_get + pd_create + pd_update + pd_delete + pd_toggle + directive_export
- *
- * Project Directives management tools for the Nexus platform.
- * Directives are project-scoped rules/policies that guide agent behavior.
- * Delegates to POST /api/mcp/directives.
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function errorResult(result: { error: string | null }) {
-  return {
-    content: [
-      {
-        type: 'text' as const,
-        text: JSON.stringify({ error: result.error }, null, 2),
-      },
-    ],
-    isError: true,
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function okResult(data: any) {
-  return {
-    content: [
-      { type: 'text' as const, text: JSON.stringify(data, null, 2) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// pd_list
-// ---------------------------------------------------------------------------
-
-export const pdListSchema = {
-  project_id: z
-    .string()
-    .uuid()
-    .describe('Project UUID'),
-  enabled: z
-    .boolean()
-    .optional()
-    .describe('Filter by enabled status'),
-  limit: z
-    .number()
-    .min(1)
-    .max(100)
-    .default(50)
-    .describe('Maximum results to return'),
-}
-
-type PdListArgs = {
-  project_id: string
-  enabled?: boolean
-  limit?: number
-  user_id: string
-}
-
-export async function pdList(args: PdListArgs) {
-  const result = await nexusPost('/api/mcp/directives', {
-    action: 'pd_list',
-    project_id: args.project_id,
-    enabled: args.enabled,
-    limit: args.limit ?? 50,
-  })
-
-  if (!result.ok) return errorResult(result)
-  return okResult(result.data)
-}
-
-// ---------------------------------------------------------------------------
-// pd_get
-// ---------------------------------------------------------------------------
-
-export const pdGetSchema = {
-  directive_id: z
-    .string()
-    .uuid()
-    .describe('Directive UUID'),
-}
-
-type PdGetArgs = {
-  directive_id: string
-  user_id: string
-}
-
-export async function pdGet(args: PdGetArgs) {
-  const result = await nexusPost('/api/mcp/directives', {
-    action: 'pd_get',
-    directive_id: args.directive_id,
-  })
-
-  if (!result.ok) return errorResult(result)
-  return okResult(result.data)
-}
-
-// ---------------------------------------------------------------------------
-// pd_create
-// ---------------------------------------------------------------------------
-
-export const pdCreateSchema = {
-  project_id: z
-    .string()
-    .uuid()
-    .describe('Project UUID'),
-  title: z
-    .string()
-    .max(500)
-    .describe('Directive title'),
-  body: z
-    .string()
-    .max(10000)
-    .optional()
-    .describe('Directive body (markdown)'),
-  category: z
-    .string()
-    .max(100)
-    .default('general')
-    .describe('Directive category (e.g. general, security, deployment)'),
-  priority: z
-    .enum(['low', 'medium', 'high'])
-    .default('medium')
-    .describe('Directive priority'),
-  enabled: z
-    .boolean()
-    .default(true)
-    .describe('Whether the directive is enabled'),
-}
-
-type PdCreateArgs = {
-  project_id: string
-  title: string
-  body?: string
-  category?: string
-  priority?: string
-  enabled?: boolean
-  user_id: string
-}
-
-export async function pdCreate(args: PdCreateArgs) {
-  const result = await nexusPost('/api/mcp/directives', {
-    action: 'pd_create',
-    project_id: args.project_id,
-    title: args.title,
-    body: args.body,
-    category: args.category ?? 'general',
-    priority: args.priority ?? 'medium',
-    enabled: args.enabled !== false,
-  })
-
-  if (!result.ok) return errorResult(result)
-  return okResult(result.data)
-}
-
-// ---------------------------------------------------------------------------
-// pd_update
-// ---------------------------------------------------------------------------
-
-export const pdUpdateSchema = {
-  directive_id: z
-    .string()
-    .uuid()
-    .describe('Directive UUID'),
-  title: z
-    .string()
-    .max(500)
-    .optional()
-    .describe('Updated title'),
-  body: z
-    .string()
-    .max(10000)
-    .optional()
-    .describe('Updated body (markdown)'),
-  category: z
-    .string()
-    .max(100)
-    .optional()
-    .describe('Updated category'),
-  priority: z
-    .enum(['low', 'medium', 'high'])
-    .optional()
-    .describe('Updated priority'),
-  enabled: z
-    .boolean()
-    .optional()
-    .describe('Updated enabled state'),
-}
-
-type PdUpdateArgs = {
-  directive_id: string
-  title?: string
-  body?: string
-  category?: string
-  priority?: string
-  enabled?: boolean
-  user_id: string
-}
-
-export async function pdUpdate(args: PdUpdateArgs) {
-  const result = await nexusPost('/api/mcp/directives', {
-    action: 'pd_update',
-    directive_id: args.directive_id,
-    title: args.title,
-    body: args.body,
-    category: args.category,
-    priority: args.priority,
-    enabled: args.enabled,
-  })
-
-  if (!result.ok) return errorResult(result)
-  return okResult(result.data)
-}
-
-// ---------------------------------------------------------------------------
-// pd_delete
-// ---------------------------------------------------------------------------
-
-export const pdDeleteSchema = {
-  directive_id: z
-    .string()
-    .uuid()
-    .describe('Directive UUID to delete'),
-}
-
-type PdDeleteArgs = {
-  directive_id: string
-  user_id: string
-}
-
-export async function pdDelete(args: PdDeleteArgs) {
-  const result = await nexusPost('/api/mcp/directives', {
-    action: 'pd_delete',
-    directive_id: args.directive_id,
-  })
-
-  if (!result.ok) return errorResult(result)
-  return okResult(result.data)
-}
-
-// ---------------------------------------------------------------------------
-// pd_toggle
-// ---------------------------------------------------------------------------
-
-export const pdToggleSchema = {
-  directive_id: z
-    .string()
-    .uuid()
-    .describe('Directive UUID to toggle'),
-  enabled: z
-    .boolean()
-    .optional()
-    .describe('Explicit enabled state (omit to invert current)'),
-}
-
-type PdToggleArgs = {
-  directive_id: string
-  enabled?: boolean
-  user_id: string
-}
-
-export async function pdToggle(args: PdToggleArgs) {
-  const result = await nexusPost('/api/mcp/directives', {
-    action: 'pd_toggle',
-    directive_id: args.directive_id,
-    enabled: args.enabled,
-  })
-
-  if (!result.ok) return errorResult(result)
-  return okResult(result.data)
-}
-
-// ---------------------------------------------------------------------------
-// directive_export
-// ---------------------------------------------------------------------------
-
-export const directiveExportSchema = {
-  project_id: z
-    .string()
-    .uuid()
-    .describe('Project UUID'),
-}
-
-type DirectiveExportArgs = {
-  project_id: string
-  user_id: string
-}
-
-export async function directiveExport(args: DirectiveExportArgs) {
-  const result = await nexusPost('/api/mcp/directives', {
-    action: 'directive_export',
-    project_id: args.project_id,
-  })
-
-  if (!result.ok) return errorResult(result)
-  return okResult(result.data)
-}