prjct-cli 0.20.1 → 0.22.0

package/core/integrations/notion/client.ts

@@ -0,0 +1,413 @@
+/**
+ * Notion Client
+ * Wrapper for Notion MCP tools with fallback to direct API.
+ *
+ * Uses MCP tools when available (via Claude), falls back to fetch for CLI usage.
+ */
+
+import type { NotionIntegrationConfig } from '../../types/integrations'
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface NotionDatabase {
+  id: string
+  title: string
+  url: string
+}
+
+export interface NotionPage {
+  id: string
+  url: string
+}
+
+export interface NotionProperty {
+  type: string
+  [key: string]: unknown
+}
+
+export interface NotionDatabaseSchema {
+  title: string
+  properties: Record<string, NotionProperty>
+}
+
+export interface NotionQueryFilter {
+  property: string
+  rich_text?: { equals: string }
+  title?: { equals: string }
+  date?: { equals: string }
+}
+
+// Notion API response types
+interface NotionApiResponse {
+  id?: string
+  url?: string
+  bot?: {
+    workspace_name?: string
+    owner?: {
+      workspace?: {
+        id?: string
+      }
+    }
+  }
+  results?: Array<{ id: string; properties: Record<string, unknown> }>
+}
+
+// =============================================================================
+// Notion Client Class
+// =============================================================================
+
+export class NotionClient {
+  private config: NotionIntegrationConfig | null = null
+  private apiToken: string | null = null
+
+  /**
+   * Initialize client with config
+   */
+  initialize(config: NotionIntegrationConfig, apiToken?: string): void {
+    this.config = config
+    this.apiToken = apiToken || process.env.NOTION_TOKEN || null
+  }
+
+  /**
+   * Check if client is ready
+   */
+  isReady(): boolean {
+    return this.config?.enabled === true && this.apiToken !== null
+  }
+
+  /**
+   * Get workspace info
+   */
+  async getWorkspace(): Promise<{ id: string; name: string } | null> {
+    if (!this.apiToken) return null
+
+    try {
+      const response = await this.apiRequest('/users/me')
+      if (response.bot?.workspace_name) {
+        return {
+          id: response.bot.owner?.workspace?.id || 'unknown',
+          name: response.bot.workspace_name,
+        }
+      }
+      return null
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Create a database in Notion
+   */
+  async createDatabase(
+    parentPageId: string,
+    schema: NotionDatabaseSchema
+  ): Promise<NotionDatabase | null> {
+    try {
+      const response = await this.apiRequest('/databases', 'POST', {
+        parent: { type: 'page_id', page_id: parentPageId },
+        title: [{ type: 'text', text: { content: schema.title } }],
+        properties: schema.properties,
+      })
+
+      if (!response.id || !response.url) {
+        return null
+      }
+
+      return {
+        id: response.id,
+        title: schema.title,
+        url: response.url,
+      }
+    } catch (error) {
+      console.error('[notion] Failed to create database:', (error as Error).message)
+      return null
+    }
+  }
+
+  /**
+   * Create a page in a database
+   */
+  async createPage(
+    databaseId: string,
+    properties: Record<string, unknown>
+  ): Promise<NotionPage | null> {
+    try {
+      const response = await this.apiRequest('/pages', 'POST', {
+        parent: { type: 'database_id', database_id: databaseId },
+        properties,
+      })
+
+      if (!response.id || !response.url) {
+        return null
+      }
+
+      return {
+        id: response.id,
+        url: response.url,
+      }
+    } catch (error) {
+      console.error('[notion] Failed to create page:', (error as Error).message)
+      return null
+    }
+  }
+
+  /**
+   * Update a page
+   */
+  async updatePage(
+    pageId: string,
+    properties: Record<string, unknown>
+  ): Promise<NotionPage | null> {
+    try {
+      const response = await this.apiRequest(`/pages/${pageId}`, 'PATCH', {
+        properties,
+      })
+
+      if (!response.id || !response.url) {
+        return null
+      }
+
+      return {
+        id: response.id,
+        url: response.url,
+      }
+    } catch (error) {
+      console.error('[notion] Failed to update page:', (error as Error).message)
+      return null
+    }
+  }
+
+  /**
+   * Update page content (for dashboard)
+   */
+  async updatePageContent(pageId: string, content: string): Promise<boolean> {
+    try {
+      // Convert markdown content to Notion blocks
+      const blocks = this.markdownToBlocks(content)
+
+      // Clear existing content and add new blocks
+      // First, get existing blocks to delete them
+      const existingBlocks = await this.apiRequest(
+        `/blocks/${pageId}/children`,
+        'GET'
+      )
+
+      // Delete existing blocks
+      for (const block of existingBlocks.results || []) {
+        await this.apiRequest(`/blocks/${block.id}`, 'DELETE')
+      }
+
+      // Add new blocks
+      await this.apiRequest(`/blocks/${pageId}/children`, 'PATCH', {
+        children: blocks,
+      })
+
+      return true
+    } catch (error) {
+      console.error('[notion] Failed to update page content:', (error as Error).message)
+      return false
+    }
+  }
+
+  /**
+   * Convert simple markdown to Notion blocks
+   */
+  private markdownToBlocks(content: string): unknown[] {
+    const blocks: unknown[] = []
+    const lines = content.split('\n')
+
+    for (const line of lines) {
+      if (line.startsWith('# ')) {
+        blocks.push({
+          type: 'heading_1',
+          heading_1: {
+            rich_text: [{ type: 'text', text: { content: line.slice(2) } }],
+          },
+        })
+      } else if (line.startsWith('## ')) {
+        blocks.push({
+          type: 'heading_2',
+          heading_2: {
+            rich_text: [{ type: 'text', text: { content: line.slice(3) } }],
+          },
+        })
+      } else if (line.startsWith('- ')) {
+        blocks.push({
+          type: 'bulleted_list_item',
+          bulleted_list_item: {
+            rich_text: [{ type: 'text', text: { content: line.slice(2) } }],
+          },
+        })
+      } else if (line.startsWith('|') && line.includes('|')) {
+        // Table row - skip header separator
+        if (!line.match(/^\|[-|]+\|$/)) {
+          const cells = line.split('|').filter(Boolean).map((c) => c.trim())
+          if (cells.length > 0) {
+            blocks.push({
+              type: 'paragraph',
+              paragraph: {
+                rich_text: [{ type: 'text', text: { content: cells.join(' | ') } }],
+              },
+            })
+          }
+        }
+      } else if (line.trim() === '---') {
+        blocks.push({ type: 'divider', divider: {} })
+      } else if (line.trim()) {
+        blocks.push({
+          type: 'paragraph',
+          paragraph: {
+            rich_text: [{ type: 'text', text: { content: line } }],
+          },
+        })
+      }
+    }
+
+    return blocks
+  }
+
+  /**
+   * Query a database
+   */
+  async queryDatabase(
+    databaseId: string,
+    filter?: NotionQueryFilter
+  ): Promise<Array<{ id: string; properties: Record<string, unknown> }>> {
+    try {
+      const body: Record<string, unknown> = {}
+      if (filter) {
+        body.filter = filter
+      }
+
+      const response = await this.apiRequest(
+        `/databases/${databaseId}/query`,
+        'POST',
+        body
+      )
+
+      return (response.results || []).map(
+        (page: { id: string; properties: Record<string, unknown> }) => ({
+          id: page.id,
+          properties: page.properties,
+        })
+      )
+    } catch (error) {
+      console.error('[notion] Failed to query database:', (error as Error).message)
+      return []
+    }
+  }
+
+  /**
+   * Find page by name (for upsert)
+   * Note: Since each project has its own database, we don't need to filter by project
+   */
+  async findPageByProjectAndName(
+    databaseId: string,
+    _projectId: string,
+    name: string
+  ): Promise<string | null> {
+    try {
+      const response = await this.apiRequest(
+        `/databases/${databaseId}/query`,
+        'POST',
+        {
+          filter: {
+            or: [
+              { property: 'Name', title: { equals: name } },
+              { property: 'Idea', title: { equals: name } },
+            ],
+          },
+        }
+      )
+
+      const results = response.results || []
+      return results.length > 0 ? results[0].id : null
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Create a page (for dashboard)
+   */
+  async createDashboardPage(
+    parentPageId: string,
+    title: string,
+    content: string
+  ): Promise<NotionPage | null> {
+    try {
+      const response = await this.apiRequest('/pages', 'POST', {
+        parent: { type: 'page_id', page_id: parentPageId },
+        properties: {
+          title: [{ type: 'text', text: { content: title } }],
+        },
+        children: [
+          {
+            object: 'block',
+            type: 'paragraph',
+            paragraph: {
+              rich_text: [{ type: 'text', text: { content } }],
+            },
+          },
+        ],
+      })
+
+      if (!response.id || !response.url) {
+        return null
+      }
+
+      return {
+        id: response.id,
+        url: response.url,
+      }
+    } catch (error) {
+      console.error('[notion] Failed to create page:', (error as Error).message)
+      return null
+    }
+  }
+
+  /**
+   * Make API request to Notion
+   */
+  private async apiRequest(
+    endpoint: string,
+    method = 'GET',
+    body?: Record<string, unknown>
+  ): Promise<NotionApiResponse> {
+    if (!this.apiToken) {
+      throw new Error('Notion API token not configured')
+    }
+
+    const url = `https://api.notion.com/v1${endpoint}`
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.apiToken}`,
+      'Content-Type': 'application/json',
+      'Notion-Version': '2022-06-28',
+    }
+
+    const options: RequestInit = {
+      method,
+      headers,
+    }
+
+    if (body) {
+      options.body = JSON.stringify(body)
+    }
+
+    const response = await fetch(url, options)
+
+    if (!response.ok) {
+      const errorData = (await response.json().catch(() => ({}))) as { message?: string }
+      throw new Error(
+        `Notion API error: ${response.status} - ${errorData.message || 'Unknown error'}`
+      )
+    }
+
+    return (await response.json()) as NotionApiResponse
+  }
+}
+
+// Singleton instance
+export const notionClient = new NotionClient()

package/core/integrations/notion/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Notion Integration Module
+ * Optional integration with Notion for syncing prjct data.
+ */
+
+// Client
+export { NotionClient, notionClient } from './client'
+export type {
+  NotionDatabase,
+  NotionPage,
+  NotionProperty,
+  NotionDatabaseSchema,
+  NotionQueryFilter,
+} from './client'
+
+// Templates
+export {
+  SHIPPED_DATABASE_SCHEMA,
+  ROADMAP_DATABASE_SCHEMA,
+  IDEAS_DATABASE_SCHEMA,
+  TASKS_DATABASE_SCHEMA,
+  ALL_DATABASE_SCHEMAS,
+  getDashboardContent,
+} from './templates'
+
+// Sync
+export {
+  syncShippedFeature,
+  syncIdea,
+  fullSync,
+  pullShippedFeatures,
+  pullIdeas,
+  bidirectionalSync,
+} from './sync'
+export type { SyncResult, PullResult } from './sync'
+
+// Setup
+export {
+  checkNotionMCPAvailable,
+  validateToken,
+  createDatabases,
+  setupNotion,
+  getSetupInstructions,
+  parseNotionPageUrl,
+} from './setup'
+export type { SetupResult, ValidationResult } from './setup'

package/core/integrations/notion/setup.ts

@@ -0,0 +1,235 @@
+/**
+ * Notion Setup Flow
+ * Interactive setup for Notion integration.
+ */
+
+import type { NotionIntegrationConfig } from '../../types/integrations'
+import { DEFAULT_NOTION_CONFIG } from '../../types/integrations'
+import { notionClient } from './client'
+import {
+  ALL_DATABASE_SCHEMAS,
+  getDashboardContent,
+} from './templates'
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface SetupResult {
+  success: boolean
+  config?: NotionIntegrationConfig
+  error?: string
+  message?: string
+}
+
+export interface ValidationResult {
+  valid: boolean
+  workspaceName?: string
+  error?: string
+}
+
+// =============================================================================
+// Setup Functions
+// =============================================================================
+
+/**
+ * Check if Notion MCP is available
+ * Returns true if the MCP server is configured
+ */
+export function checkNotionMCPAvailable(): boolean {
+  // Check if running in Claude environment with MCP
+  if (typeof globalThis !== 'undefined') {
+    const g = globalThis as Record<string, unknown>
+    if (g.mcp || g.notion || process.env.NOTION_TOKEN) {
+      return true
+    }
+  }
+  return !!process.env.NOTION_TOKEN
+}
+
+/**
+ * Validate Notion API token
+ */
+export async function validateToken(token: string): Promise<ValidationResult> {
+  try {
+    // Temporarily initialize client with token
+    const tempConfig: NotionIntegrationConfig = {
+      ...DEFAULT_NOTION_CONFIG,
+      enabled: true,
+    }
+    notionClient.initialize(tempConfig, token)
+
+    const workspace = await notionClient.getWorkspace()
+    if (workspace) {
+      return {
+        valid: true,
+        workspaceName: workspace.name,
+      }
+    }
+
+    return {
+      valid: false,
+      error: 'Could not connect to Notion workspace',
+    }
+  } catch (error) {
+    return {
+      valid: false,
+      error: (error as Error).message,
+    }
+  }
+}
+
+/**
+ * Create all prjct databases in Notion
+ */
+export async function createDatabases(
+  parentPageId: string,
+  projectName: string
+): Promise<{
+  success: boolean
+  databases: NotionIntegrationConfig['databases']
+  dashboardPageId?: string
+  error?: string
+}> {
+  const databases: NotionIntegrationConfig['databases'] = {}
+
+  try {
+    // Create each database with project-specific names
+    for (const [key, schema] of Object.entries(ALL_DATABASE_SCHEMAS)) {
+      // Override title with project name prefix
+      const projectSchema = {
+        ...schema,
+        title: schema.title.replace('prjct:', `${projectName}:`),
+      }
+      const db = await notionClient.createDatabase(parentPageId, projectSchema)
+      if (db) {
+        databases[key as keyof typeof databases] = db.id
+      } else {
+        return {
+          success: false,
+          databases,
+          error: `Failed to create ${projectSchema.title} database`,
+        }
+      }
+    }
+
+    // Create dashboard page
+    const dashboardContent = getDashboardContent(projectName, databases)
+    const dashboard = await notionClient.createDashboardPage(
+      parentPageId,
+      `${projectName} Dashboard`,
+      dashboardContent
+    )
+
+    return {
+      success: true,
+      databases,
+      dashboardPageId: dashboard?.id,
+    }
+  } catch (error) {
+    return {
+      success: false,
+      databases,
+      error: (error as Error).message,
+    }
+  }
+}
+
+/**
+ * Full setup flow
+ * Called by /p:init or /p:notion setup
+ */
+export async function setupNotion(params: {
+  token: string
+  parentPageId: string
+  projectId: string
+  projectName: string
+}): Promise<SetupResult> {
+  const { token, parentPageId, projectId, projectName } = params
+
+  // Step 1: Validate token
+  const validation = await validateToken(token)
+  if (!validation.valid) {
+    return {
+      success: false,
+      error: validation.error || 'Invalid token',
+    }
+  }
+
+  // Step 2: Initialize client
+  const config: NotionIntegrationConfig = {
+    ...DEFAULT_NOTION_CONFIG,
+    enabled: true,
+    workspaceName: validation.workspaceName,
+  }
+  notionClient.initialize(config, token)
+
+  // Step 3: Create databases
+  const result = await createDatabases(parentPageId, projectName)
+  if (!result.success) {
+    return {
+      success: false,
+      error: result.error,
+    }
+  }
+
+  // Step 4: Build final config
+  const finalConfig: NotionIntegrationConfig = {
+    enabled: true,
+    workspaceName: validation.workspaceName,
+    databases: result.databases,
+    dashboardPageId: result.dashboardPageId,
+    syncOn: {
+      ship: true,
+      done: false,
+      idea: true,
+    },
+    setupAt: new Date().toISOString(),
+  }
+
+  return {
+    success: true,
+    config: finalConfig,
+    message: `Notion connected to "${validation.workspaceName}". Created 4 databases.`,
+  }
+}
+
+/**
+ * Get setup instructions for user
+ */
+export function getSetupInstructions(): string[] {
+  return [
+    '1. Go to https://www.notion.so/my-integrations',
+    '2. Click "New integration"',
+    '3. Name it "prjct-cli" and select your workspace',
+    '4. Copy the Internal Integration Secret (starts with ntn_)',
+    '5. Share a Notion page with the integration (this will be the parent)',
+    '6. Copy the page ID from the URL (the 32-character string)',
+  ]
+}
+
+/**
+ * Parse Notion page URL to get page ID
+ */
+export function parseNotionPageUrl(url: string): string | null {
+  // Handle various Notion URL formats
+  // https://www.notion.so/workspace/Page-Title-abc123def456
+  // https://notion.so/abc123def456
+  // abc123def456 (just the ID)
+
+  const cleanUrl = url.trim()
+
+  // If it's already a 32-char hex string
+  if (/^[a-f0-9]{32}$/i.test(cleanUrl)) {
+    return cleanUrl
+  }
+
+  // If it's a UUID format (with dashes)
+  if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(cleanUrl)) {
+    return cleanUrl.replace(/-/g, '')
+  }
+
+  // Try to extract from URL
+  const match = cleanUrl.match(/([a-f0-9]{32})/i)
+  return match ? match[1] : null
+}