@gwdn/nexus-mcp 0.8.7 → 0.8.9

package/src/tools/sessions.ts

@@ -1,157 +0,0 @@
-/**
- * Session lifecycle tools -- Layer 2 Coordination
- *
- * session_create:      Start a new work session for a project
- * session_close:       End a session with summary and next entry point
- * session_list:        List open sessions for a project
- *
- * Delegates to POST /api/mcp/sessions.
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-// ---------------------------------------------------------------------------
-// create_session -> session_create
-// ---------------------------------------------------------------------------
-
-export const createSessionSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-  title: z.string().max(500).describe('Session title (e.g., "Architecture review")'),
-  agent_id: z
-    .string()
-    .max(200)
-    .optional()
-    .describe('Agent identifier starting this session'),
-}
-
-type CreateSessionArgs = {
-  project_id: string
-  title: string
-  agent_id?: string
-  user_id: string
-}
-
-export async function createSession(args: CreateSessionArgs) {
-  const result = await nexusPost('/api/mcp/sessions', {
-    action: 'session_create',
-    project_id: args.project_id,
-    title: args.title,
-  })
-
-  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) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// close_session -> session_close
-// ---------------------------------------------------------------------------
-
-export const closeSessionSchema = {
-  session_id: z.string().uuid().describe('Session UUID to close'),
-  summary: z
-    .string()
-    .max(100_000)
-    .optional()
-    .describe('Summary of what was accomplished in the session'),
-  next_entry_point: z
-    .string()
-    .max(10_000)
-    .optional()
-    .describe('Suggested starting point for the next session'),
-}
-
-type CloseSessionArgs = {
-  session_id: string
-  summary?: string
-  next_entry_point?: string
-  user_id: string
-}
-
-export async function closeSession(args: CloseSessionArgs) {
-  const result = await nexusPost('/api/mcp/sessions', {
-    action: 'session_close',
-    session_id: args.session_id,
-    summary: args.summary,
-    next_entry_point: args.next_entry_point,
-  })
-
-  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_open_sessions -> session_list
-// ---------------------------------------------------------------------------
-
-export const listOpenSessionsSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-  limit: z
-    .number()
-    .int()
-    .min(1)
-    .max(100)
-    .default(25)
-    .describe('Maximum number of sessions to return (default 25)'),
-}
-
-type ListOpenSessionsArgs = {
-  project_id: string
-  limit?: number
-}
-
-export async function listOpenSessions(args: ListOpenSessionsArgs) {
-  const result = await nexusPost('/api/mcp/sessions', {
-    action: 'session_list',
-    project_id: args.project_id,
-    limit: args.limit ?? 25,
-  })
-
-  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/skill-assign.ts

@@ -1,142 +0,0 @@
-/**
- * sk_assign + sk_unassign + sk_export -- Layer 2 Coordination
- *
- * Skill-project assignment management tools for the Nexus platform.
- * Delegates to POST /api/mcp/skills.
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-// ---------------------------------------------------------------------------
-// sk_assign
-// ---------------------------------------------------------------------------
-
-export const skAssignSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-  skill_id: z.string().max(200).describe('Skill identifier or UUID'),
-  pinned_version: z
-    .number()
-    .int()
-    .optional()
-    .describe('Pin to a specific skill version'),
-  enabled: z
-    .boolean()
-    .optional()
-    .describe('Whether the assignment is enabled (default: true)'),
-}
-
-type SkAssignArgs = {
-  project_id: string
-  skill_id: string
-  pinned_version?: number
-  enabled?: boolean
-  user_id: string
-}
-
-export async function skAssign(args: SkAssignArgs) {
-  const result = await nexusPost('/api/mcp/skills', {
-    action: 'sk_assign',
-    project_id: args.project_id,
-    skill_id: args.skill_id,
-    pinned_version: args.pinned_version,
-    enabled: args.enabled,
-  })
-
-  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) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// sk_unassign
-// ---------------------------------------------------------------------------
-
-export const skUnassignSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-  skill_id: z.string().max(200).describe('Skill identifier or UUID'),
-}
-
-type SkUnassignArgs = {
-  project_id: string
-  skill_id: string
-  user_id: string
-}
-
-export async function skUnassign(args: SkUnassignArgs) {
-  const result = await nexusPost('/api/mcp/skills', {
-    action: 'sk_unassign',
-    project_id: args.project_id,
-    skill_id: args.skill_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) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// sk_export
-// ---------------------------------------------------------------------------
-
-export const skExportSchema = {
-  project_id: z.string().uuid().describe('Project UUID'),
-}
-
-type SkExportArgs = {
-  project_id: string
-  user_id: string
-}
-
-export async function skExport(args: SkExportArgs) {
-  const result = await nexusPost('/api/mcp/skills', {
-    action: 'sk_export',
-    project_id: args.project_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/skills.ts

@@ -1,255 +0,0 @@
-/**
- * sk_list + sk_get + sk_create + sk_update + sk_activate -- Layer 2 Coordination
- *
- * Skill management tools for the Nexus platform.
- * Skills are tenant-scoped instruction sets for agent sessions.
- * Delegates to POST /api/mcp/skills.
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-// ---------------------------------------------------------------------------
-// sk_list
-// ---------------------------------------------------------------------------
-
-export const skListSchema = {
-  status_filter: z
-    .array(z.enum(['draft', 'active', 'archived']))
-    .optional()
-    .describe('Filter by skill status (default: draft, active)'),
-  limit: z
-    .number()
-    .min(1)
-    .max(100)
-    .default(50)
-    .describe('Max number of skills to return'),
-}
-
-type SkListArgs = {
-  status_filter?: string[]
-  limit?: number
-  user_id: string
-}
-
-export async function skList(args: SkListArgs) {
-  const result = await nexusPost('/api/mcp/skills', {
-    action: 'sk_list',
-    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) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// sk_get
-// ---------------------------------------------------------------------------
-
-export const skGetSchema = {
-  skill_id: z
-    .string()
-    .max(200)
-    .describe('Skill identifier (e.g., nx-init-nexus) or UUID'),
-}
-
-type SkGetArgs = {
-  skill_id: string
-  user_id: string
-}
-
-export async function skGet(args: SkGetArgs) {
-  const result = await nexusPost('/api/mcp/skills', {
-    action: 'sk_get',
-    skill_id: args.skill_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) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// sk_create
-// ---------------------------------------------------------------------------
-
-export const skCreateSchema = {
-  skill_id: z.string().max(200).describe('Skill identifier (e.g., nx-init-nexus)'),
-  name: z.string().max(500).describe('Human-readable skill name'),
-  description: z.string().max(1000).optional().describe('Short description'),
-  body: z.string().max(100_000).describe('Full markdown instruction content'),
-  auto_generate_command: z
-    .boolean()
-    .default(true)
-    .describe('Auto-generate an OpenCode command (default: true)'),
-}
-
-type SkCreateArgs = {
-  skill_id: string
-  name: string
-  description?: string
-  body: string
-  auto_generate_command?: boolean
-  user_id: string
-}
-
-export async function skCreate(args: SkCreateArgs) {
-  const result = await nexusPost('/api/mcp/skills', {
-    action: 'sk_create',
-    skill_id: args.skill_id,
-    name: args.name,
-    description: args.description,
-    body: args.body,
-    auto_generate_command: args.auto_generate_command ?? true,
-  })
-
-  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) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// sk_update
-// ---------------------------------------------------------------------------
-
-export const skUpdateSchema = {
-  skill_id: z
-    .string()
-    .max(200)
-    .describe('Skill identifier (e.g., nx-init-nexus) or UUID'),
-  name: z.string().max(500).optional().describe('Updated name'),
-  description: z.string().max(1000).optional().describe('Updated description'),
-  body: z.string().max(100_000).optional().describe('Updated markdown content'),
-  auto_generate_command: z
-    .boolean()
-    .optional()
-    .describe('Toggle command auto-generation'),
-}
-
-type SkUpdateArgs = {
-  skill_id: string
-  name?: string
-  description?: string
-  body?: string
-  auto_generate_command?: boolean
-  user_id: string
-}
-
-export async function skUpdate(args: SkUpdateArgs) {
-  const result = await nexusPost('/api/mcp/skills', {
-    action: 'sk_update',
-    skill_id: args.skill_id,
-    name: args.name,
-    description: args.description,
-    body: args.body,
-    auto_generate_command: args.auto_generate_command,
-  })
-
-  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) },
-    ],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// sk_activate
-// ---------------------------------------------------------------------------
-
-export const skActivateSchema = {
-  skill_id: z
-    .string()
-    .max(200)
-    .describe('Skill identifier (e.g., nx-init-nexus) or UUID'),
-  status: z
-    .enum(['active', 'archived', 'draft'])
-    .describe('New status for the skill'),
-}
-
-type SkActivateArgs = {
-  skill_id: string
-  status: string
-  user_id: string
-}
-
-export async function skActivate(args: SkActivateArgs) {
-  const result = await nexusPost('/api/mcp/skills', {
-    action: 'sk_activate',
-    skill_id: args.skill_id,
-    status: args.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/update-document.ts

@@ -1,66 +0,0 @@
-/**
- * doc_update -- Layer 2 Coordination
- *
- * Update title, body, or source_url of an ingest item.
- * Supports full body replacement or append mode.
- * Delegates to POST /api/mcp/documents (action: doc_update).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const updateDocumentSchema = {
-  document_id: z.string().uuid().describe('Document UUID to update'),
-  title: z.string().max(500).optional().describe('New document title'),
-  body: z
-    .string()
-    .max(100_000)
-    .optional()
-    .describe('New document body (replaces existing content)'),
-  source_url: z.string().url().optional().describe('Updated source URL'),
-  append_body: z
-    .string()
-    .max(100_000)
-    .optional()
-    .describe(
-      'Content to append to existing body (ignored if body is also provided)',
-    ),
-}
-
-type UpdateDocumentArgs = {
-  document_id: string
-  title?: string
-  body?: string
-  source_url?: string
-  append_body?: string
-  user_id: string
-}
-
-export async function updateDocument(args: UpdateDocumentArgs) {
-  const result = await nexusPost('/api/mcp/documents', {
-    action: 'doc_update',
-    document_id: args.document_id,
-    title: args.title,
-    body: args.body,
-    source_url: args.source_url,
-    append_body: args.append_body,
-  })
-
-  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/update-task-status.ts

@@ -1,64 +0,0 @@
-/**
- * task_update -- Layer 2 Coordination
- *
- * Updates the status (and optionally priority/assignee) of an existing task.
- * Delegates to POST /api/mcp/tasks (action: task_update).
- */
-
-import { z } from 'zod'
-import { nexusPost } from '../nexus-api.js'
-
-export const updateTaskStatusSchema = {
-  task_id: z.string().uuid().describe('Task UUID to update'),
-  status: z
-    .enum(['open', 'in_progress', 'blocked', 'done', 'cancelled'])
-    .describe('New task status'),
-  priority: z
-    .enum(['low', 'medium', 'high', 'urgent'])
-    .optional()
-    .describe('Updated priority (optional)'),
-  assignee: z
-    .string()
-    .uuid()
-    .optional()
-    .describe('UUID of the newly assigned user (optional)'),
-  agent_id: z.string().max(200).optional().describe('Agent identifier if applicable'),
-}
-
-type UpdateTaskStatusArgs = {
-  task_id: string
-  status: string
-  priority?: string
-  assignee?: string
-  user_id: string
-  agent_id?: string
-}
-
-export async function updateTaskStatus(args: UpdateTaskStatusArgs) {
-  const result = await nexusPost('/api/mcp/tasks', {
-    action: 'task_update',
-    task_id: args.task_id,
-    status: args.status,
-    priority: args.priority,
-    assignee: args.assignee,
-    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) },
-    ],
-  }
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "lib": ["ES2022"],
-    "types": ["node"],
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "src/__tests__"]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    globals: true,
-    setupFiles: ['./src/__tests__/setup.ts'],
-  },
-})