popilot 0.6.0 → 0.8.0

package/scaffold/mcp-notification-server/src/index.ts

@@ -0,0 +1,275 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { z } from 'zod'
+import { query, execute } from './turso-client.js'
+
+const server = new McpServer({
+  name: 'spec-notifications',
+  version: '1.0.0',
+})
+
+// Tool 1: Check unread notifications
+server.tool(
+  'check_notifications',
+  'Check unread notifications for a user (max 20)',
+  { user_name: z.string().describe('User name to check notifications for') },
+  async ({ user_name }) => {
+    const result = await query<{
+      id: number; type: string; title: string; body: string | null
+      source_type: string; source_id: number; page_id: string
+      actor: string; is_read: number; created_at: string
+    }>(
+      `SELECT id, type, title, body, source_type, source_id, page_id, actor, is_read, created_at
+       FROM notifications
+       WHERE user_name = ? AND is_read = 0
+       ORDER BY created_at DESC
+       LIMIT 20`,
+      [user_name],
+    )
+
+    if (result.error) {
+      return { content: [{ type: 'text' as const, text: `Error: ${result.error}` }] }
+    }
+
+    if (result.rows.length === 0) {
+      return { content: [{ type: 'text' as const, text: `No unread notifications for ${user_name}.` }] }
+    }
+
+    const lines = result.rows.map((n, i) => {
+      const icon = n.type === 'memo_assigned' ? '📩' : n.type === 'reply_received' ? '💬' : '📢'
+      return `${i + 1}. ${icon} [ID:${n.id}] ${n.title}\n   ${n.body ?? ''}\n   Page: ${n.page_id} | ${n.created_at}`
+    })
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: `Unread notifications for ${user_name} (${result.rows.length}):\n\n${lines.join('\n\n')}`,
+      }],
+    }
+  },
+)
+
+// Tool 2: Mark notification as read
+server.tool(
+  'mark_notification_read',
+  'Mark a notification as read by ID',
+  { notification_id: z.number().describe('Notification ID to mark as read') },
+  async ({ notification_id }) => {
+    const result = await execute(
+      'UPDATE notifications SET is_read = 1 WHERE id = ?',
+      [notification_id],
+    )
+
+    if (result.error) {
+      return { content: [{ type: 'text' as const, text: `Error: ${result.error}` }] }
+    }
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: result.rowsAffected > 0
+          ? `Notification #${notification_id} marked as read.`
+          : `Notification #${notification_id} not found.`,
+      }],
+    }
+  },
+)
+
+// Tool 3: Check open memos assigned to user
+server.tool(
+  'check_open_memos',
+  'Check all open memos assigned to a user',
+  { user_name: z.string().describe('User name to check memos for') },
+  async ({ user_name }) => {
+    const result = await query<{
+      id: number; page_id: string; content: string; memo_type: string
+      created_by: string; assigned_to: string | null; created_at: string
+    }>(
+      `SELECT id, page_id, content, memo_type, created_by, assigned_to, created_at
+       FROM memos_v2
+       WHERE assigned_to = ? AND status = 'open'
+       ORDER BY created_at DESC`,
+      [user_name],
+    )
+
+    if (result.error) {
+      return { content: [{ type: 'text' as const, text: `Error: ${result.error}` }] }
+    }
+
+    if (result.rows.length === 0) {
+      return { content: [{ type: 'text' as const, text: `No open memos assigned to ${user_name}.` }] }
+    }
+
+    const typeIcons: Record<string, string> = {
+      memo: '📝', decision: '⚡', request: '📋', backlog: '💡',
+    }
+
+    const lines = result.rows.map((m, i) => {
+      const icon = typeIcons[m.memo_type] ?? '📝'
+      const preview = m.content.length > 80 ? m.content.slice(0, 80) + '…' : m.content
+      return `${i + 1}. ${icon} [ID:${m.id}] ${m.created_by} → ${m.assigned_to}\n   ${preview}\n   Page: ${m.page_id} | ${m.created_at}`
+    })
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: `Open memos for ${user_name} (${result.rows.length}):\n\n${lines.join('\n\n')}`,
+      }],
+    }
+  },
+)
+
+// Tool 4: Create notification
+server.tool(
+  'create_notification',
+  'Create a notification for a user (memo events: assignment, reply, resolve, reopen)',
+  {
+    user_name: z.string().describe('Notification recipient'),
+    type: z.enum(['memo_assigned', 'memo_mention_all', 'reply_received', 'memo_resolved', 'memo_reopened'])
+      .describe('Notification type'),
+    title: z.string().describe('Notification title'),
+    body: z.string().optional().describe('Preview body (60 chars max)'),
+    source_id: z.number().describe('Related memo ID'),
+    page_id: z.string().describe('Page ID the memo belongs to'),
+    actor: z.string().describe('Name of the person who performed the action'),
+  },
+  async ({ user_name, type, title, body, source_id, page_id, actor }) => {
+    const result = await execute(
+      `INSERT INTO notifications (user_name, type, title, body, source_type, source_id, page_id, actor)
+       VALUES (?, ?, ?, ?, 'memo', ?, ?, ?)`,
+      [user_name, type, title, body ?? null, source_id, page_id, actor],
+    )
+
+    if (result.error) {
+      return { content: [{ type: 'text' as const, text: `Error: ${result.error}` }] }
+    }
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: `Notification created: [${type}] "${title}" for ${user_name}`,
+      }],
+    }
+  },
+)
+
+// Tool 5: Reply to memo
+server.tool(
+  'reply_memo',
+  'Reply to a memo and notify the memo author',
+  {
+    memo_id: z.number().describe('Memo ID to reply to'),
+    content: z.string().describe('Reply content'),
+    created_by: z.string().describe('Reply author name'),
+  },
+  async ({ memo_id, content, created_by }) => {
+    const memo = await query<{
+      id: number; page_id: string; created_by: string; assigned_to: string | null; status: string
+    }>(
+      'SELECT id, page_id, created_by, assigned_to, status FROM memos_v2 WHERE id = ?',
+      [memo_id],
+    )
+
+    if (memo.error) {
+      return { content: [{ type: 'text' as const, text: `Error: ${memo.error}` }] }
+    }
+    if (memo.rows.length === 0) {
+      return { content: [{ type: 'text' as const, text: `Memo #${memo_id} not found.` }] }
+    }
+
+    const m = memo.rows[0]
+
+    const insertResult = await execute(
+      'INSERT INTO memo_replies (memo_id, content, created_by) VALUES (?, ?, ?)',
+      [memo_id, content, created_by],
+    )
+
+    if (insertResult.error) {
+      return { content: [{ type: 'text' as const, text: `Error: ${insertResult.error}` }] }
+    }
+
+    // Notify memo author (skip self-notification)
+    if (m.created_by !== created_by) {
+      await execute(
+        `INSERT INTO notifications (user_name, type, title, body, source_type, source_id, page_id, actor)
+         VALUES (?, 'reply_received', ?, ?, 'memo', ?, ?, ?)`,
+        [
+          m.created_by,
+          `${created_by} replied to your memo`,
+          content.length > 60 ? content.slice(0, 57) + '…' : content,
+          memo_id,
+          m.page_id,
+          created_by,
+        ],
+      )
+    }
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: `Reply posted on memo #${memo_id} by ${created_by}.\nContent: ${content}`,
+      }],
+    }
+  },
+)
+
+// Tool 6: Resolve memo
+server.tool(
+  'resolve_memo',
+  'Mark a memo as resolved and notify related users',
+  {
+    memo_id: z.number().describe('Memo ID to resolve'),
+    resolved_by: z.string().describe('Name of resolver'),
+  },
+  async ({ memo_id, resolved_by }) => {
+    const memo = await query<{
+      id: number; page_id: string; created_by: string; assigned_to: string | null; status: string
+    }>(
+      'SELECT id, page_id, created_by, assigned_to, status FROM memos_v2 WHERE id = ?',
+      [memo_id],
+    )
+
+    if (memo.error) {
+      return { content: [{ type: 'text' as const, text: `Error: ${memo.error}` }] }
+    }
+    if (memo.rows.length === 0) {
+      return { content: [{ type: 'text' as const, text: `Memo #${memo_id} not found.` }] }
+    }
+
+    const m = memo.rows[0]
+    if (m.status === 'resolved') {
+      return { content: [{ type: 'text' as const, text: `Memo #${memo_id} is already resolved.` }] }
+    }
+
+    const updateResult = await execute(
+      "UPDATE memos_v2 SET status = 'resolved' WHERE id = ?",
+      [memo_id],
+    )
+
+    if (updateResult.error) {
+      return { content: [{ type: 'text' as const, text: `Error: ${updateResult.error}` }] }
+    }
+
+    if (m.created_by !== resolved_by) {
+      await execute(
+        `INSERT INTO notifications (user_name, type, title, body, source_type, source_id, page_id, actor)
+         VALUES (?, 'memo_resolved', ?, NULL, 'memo', ?, ?, ?)`,
+        [m.created_by, `${resolved_by} resolved the memo`, memo_id, m.page_id, resolved_by],
+      )
+    }
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: `Memo #${memo_id} resolved by ${resolved_by}.`,
+      }],
+    }
+  },
+)
+
+async function main() {
+  const transport = new StdioServerTransport()
+  await server.connect(transport)
+}
+
+main().catch(console.error)

package/scaffold/mcp-notification-server/src/turso-client.ts

@@ -0,0 +1,142 @@
+/**
+ * Database HTTP API client (Turso Hrana v2 protocol)
+ * Reads DB_URL and DB_AUTH_TOKEN from environment.
+ */
+
+const DB_URL = process.env.DB_URL ?? ''
+const DB_AUTH_TOKEN = process.env.DB_AUTH_TOKEN ?? ''
+
+type ArgValue = string | number | null
+
+interface HranaValue {
+  type: 'text' | 'integer' | 'float' | 'null'
+  value?: string
+}
+
+function toHranaArg(v: ArgValue): HranaValue {
+  if (v === null) return { type: 'null' }
+  if (typeof v === 'number') {
+    return Number.isInteger(v)
+      ? { type: 'integer', value: String(v) }
+      : { type: 'float', value: String(v) }
+  }
+  return { type: 'text', value: String(v) }
+}
+
+interface PipelineResult {
+  results: Array<{
+    type: 'ok' | 'error'
+    response?: {
+      type: string
+      result?: {
+        cols: Array<{ name: string }>
+        rows: Array<Array<HranaValue>>
+        affected_row_count: number
+        last_insert_rowid: string | null
+      }
+    }
+    error?: { message: string }
+  }>
+}
+
+export async function query<T = Record<string, unknown>>(
+  sql: string,
+  args: ArgValue[] = [],
+): Promise<{ rows: T[]; error?: string }> {
+  if (!DB_URL || !DB_AUTH_TOKEN) {
+    return { rows: [], error: 'Missing DB_URL or DB_AUTH_TOKEN' }
+  }
+
+  try {
+    const resp = await fetch(DB_URL + '/v2/pipeline', {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer ' + DB_AUTH_TOKEN,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        requests: [
+          { type: 'execute', stmt: { sql, args: args.map(toHranaArg) } },
+          { type: 'close' },
+        ],
+      }),
+      signal: AbortSignal.timeout(10000),
+    })
+
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '')
+      return { rows: [], error: `HTTP ${resp.status}: ${text}` }
+    }
+
+    const data: PipelineResult = await resp.json()
+    const first = data.results[0]
+
+    if (first.type === 'error') {
+      return { rows: [], error: first.error?.message ?? 'Unknown error' }
+    }
+
+    const result = first.response?.result
+    if (!result) return { rows: [] }
+
+    const colNames = result.cols.map(c => c.name)
+    const rows = result.rows.map(row => {
+      const obj: Record<string, unknown> = {}
+      colNames.forEach((col, i) => {
+        const cell = row[i]
+        if (cell.type === 'null') obj[col] = null
+        else if (cell.type === 'integer') obj[col] = Number(cell.value)
+        else if (cell.type === 'float') obj[col] = Number(cell.value)
+        else obj[col] = cell.value
+      })
+      return obj as T
+    })
+
+    return { rows }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Unknown error'
+    return { rows: [], error: message }
+  }
+}
+
+export async function execute(
+  sql: string,
+  args: ArgValue[] = [],
+): Promise<{ rowsAffected: number; error?: string }> {
+  if (!DB_URL || !DB_AUTH_TOKEN) {
+    return { rowsAffected: 0, error: 'Missing DB_URL or DB_AUTH_TOKEN' }
+  }
+
+  try {
+    const resp = await fetch(DB_URL + '/v2/pipeline', {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer ' + DB_AUTH_TOKEN,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        requests: [
+          { type: 'execute', stmt: { sql, args: args.map(toHranaArg) } },
+          { type: 'close' },
+        ],
+      }),
+      signal: AbortSignal.timeout(10000),
+    })
+
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '')
+      return { rowsAffected: 0, error: `HTTP ${resp.status}: ${text}` }
+    }
+
+    const data: PipelineResult = await resp.json()
+    const first = data.results[0]
+
+    if (first.type === 'error') {
+      return { rowsAffected: 0, error: first.error?.message ?? 'Unknown error' }
+    }
+
+    return { rowsAffected: first.response?.result?.affected_row_count ?? 0 }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Unknown error'
+    return { rowsAffected: 0, error: message }
+  }
+}

package/scaffold/mcp-notification-server/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src"]
+}

package/scaffold/mcp-pm/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "mcp-pm",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/scaffold/mcp-pm/src/api-client.ts

@@ -0,0 +1,69 @@
+// PM API HTTP client
+// All MCP tools use this client to communicate with the PM API server.
+// Required env vars: PM_API_URL, PM_TOKEN
+
+const PM_API_URL = process.env.PM_API_URL ?? ''
+const PM_TOKEN = process.env.PM_TOKEN ?? ''
+
+interface ApiResult<T> {
+  data: T | null
+  error?: string
+}
+
+async function request<T>(method: string, path: string, body?: unknown): Promise<ApiResult<T>> {
+  if (!PM_API_URL || !PM_TOKEN) {
+    return { data: null, error: 'Missing PM_API_URL or PM_TOKEN' }
+  }
+
+  try {
+    const resp = await fetch(`${PM_API_URL}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${PM_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+      body: body ? JSON.stringify(body) : undefined,
+      signal: AbortSignal.timeout(15000),
+    })
+
+    const data = await resp.json()
+
+    if (!resp.ok) {
+      return { data: null, error: data.error ?? `HTTP ${resp.status}` }
+    }
+
+    return { data: data as T }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Unknown error'
+    return { data: null, error: message }
+  }
+}
+
+export function apiGet<T>(path: string, params?: Record<string, string>): Promise<ApiResult<T>> {
+  let url = path
+  if (params) {
+    const search = new URLSearchParams()
+    for (const [k, v] of Object.entries(params)) {
+      if (v) search.set(k, v)
+    }
+    const qs = search.toString()
+    if (qs) url += '?' + qs
+  }
+  return request<T>('GET', url)
+}
+
+export function apiPost<T>(path: string, body: unknown): Promise<ApiResult<T>> {
+  return request<T>('POST', path, body)
+}
+
+export function apiPatch<T>(path: string, body: unknown): Promise<ApiResult<T>> {
+  return request<T>('PATCH', path, body)
+}
+
+export function apiPut<T>(path: string, body: unknown): Promise<ApiResult<T>> {
+  return request<T>('PUT', path, body)
+}
+
+export function apiDelete<T>(path: string): Promise<ApiResult<T>> {
+  return request<T>('DELETE', path)
+}