@ainyc/canonry 1.0.1 → 1.1.2

package/src/cli.ts

@@ -1,470 +0,0 @@
-#!/usr/bin/env node --import tsx
-import { parseArgs } from 'node:util'
-import { initCommand } from './commands/init.js'
-import { serveCommand } from './commands/serve.js'
-import { createProject, listProjects, showProject, deleteProject } from './commands/project.js'
-import { addKeywords, listKeywords, importKeywords } from './commands/keyword.js'
-import { addCompetitors, listCompetitors } from './commands/competitor.js'
-import { triggerRun, listRuns } from './commands/run.js'
-import { showStatus } from './commands/status.js'
-import { showEvidence } from './commands/evidence.js'
-import { showHistory } from './commands/history.js'
-import { applyConfig } from './commands/apply.js'
-import { exportProject } from './commands/export-cmd.js'
-import { showSettings, setProvider } from './commands/settings.js'
-import { setSchedule, showSchedule, enableSchedule, disableSchedule, removeSchedule } from './commands/schedule.js'
-import { addNotification, listNotifications, removeNotification, testNotification } from './commands/notify.js'
-
-const USAGE = `
-canonry — AEO monitoring CLI
-
-Usage:
-  canonry init                        Initialize config and database
-  canonry serve                       Start the local server
-  canonry project create <name>       Create a project
-  canonry project list                List all projects
-  canonry project show <name>         Show project details
-  canonry project delete <name>       Delete a project
-  canonry keyword add <project> <kw>  Add keywords to a project
-  canonry keyword list <project>      List keywords for a project
-  canonry keyword import <project> <file>  Import keywords from file
-  canonry competitor add <project> <domain>  Add competitors
-  canonry competitor list <project>   List competitors
-  canonry run <project>               Trigger a run (all providers)
-  canonry run <project> --provider <name>  Trigger a run for a specific provider
-  canonry runs <project>              List runs for a project
-  canonry status <project>            Show project summary
-  canonry evidence <project>          Show keyword-level results
-  canonry history <project>           Show audit trail
-  canonry export <project>            Export project as YAML
-  canonry apply <file>                Apply declarative config
-  canonry schedule set <project>      Set schedule (--preset or --cron)
-  canonry schedule show <project>     Show schedule
-  canonry schedule enable <project>   Enable schedule
-  canonry schedule disable <project>  Disable schedule
-  canonry schedule remove <project>   Remove schedule
-  canonry notify add <project>        Add webhook notification
-  canonry notify list <project>       List notifications
-  canonry notify remove <project> <id>  Remove notification
-  canonry notify test <project> <id>  Send test webhook
-  canonry settings                    Show active provider and quota settings
-  canonry settings provider <name>    Update a provider config (--api-key, --base-url, --model)
-  canonry --help                      Show this help
-  canonry --version                   Show version
-
-Options:
-  --port <port>        Server port (default: 4100)
-  --domain <domain>    Canonical domain for project create
-  --country <code>     Country code (default: US)
-  --language <lang>    Language code (default: en)
-  --provider <name>    Provider to use (gemini, openai, claude)
-  --include-results    Include results in export
-  --preset <preset>    Schedule preset (daily, weekly, twice-daily, daily@HH, weekly@DAY)
-  --cron <expr>        Cron expression for schedule
-  --timezone <tz>      IANA timezone for schedule (default: UTC)
-  --webhook <url>      Webhook URL for notifications
-  --events <list>      Comma-separated notification events
-`.trim()
-
-const VERSION = '0.1.0'
-
-async function main() {
-  const args = process.argv.slice(2)
-
-  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
-    console.log(USAGE)
-    return
-  }
-
-  if (args.includes('--version') || args.includes('-v')) {
-    console.log(VERSION)
-    return
-  }
-
-  const command = args[0]!
-
-  try {
-    switch (command) {
-      case 'init':
-        await initCommand()
-        break
-
-      case 'serve': {
-        const { values } = parseArgs({
-          args: args.slice(1),
-          options: {
-            port: { type: 'string', short: 'p', default: '4100' },
-          },
-          allowPositionals: false,
-        })
-        process.env.CANONRY_PORT = values.port
-        await serveCommand()
-        break
-      }
-
-      case 'project': {
-        const subcommand = args[1]
-        switch (subcommand) {
-          case 'create': {
-            const name = args[2]
-            if (!name) {
-              console.error('Error: project name is required')
-              process.exit(1)
-            }
-            const { values } = parseArgs({
-              args: args.slice(3),
-              options: {
-                domain: { type: 'string', short: 'd' },
-                country: { type: 'string', default: 'US' },
-                language: { type: 'string', default: 'en' },
-                'display-name': { type: 'string' },
-              },
-              allowPositionals: false,
-            })
-            await createProject(name, {
-              domain: values.domain ?? name,
-              country: values.country ?? 'US',
-              language: values.language ?? 'en',
-              displayName: values['display-name'] ?? name,
-            })
-            break
-          }
-          case 'list':
-            await listProjects()
-            break
-          case 'show': {
-            const name = args[2]
-            if (!name) {
-              console.error('Error: project name is required')
-              process.exit(1)
-            }
-            await showProject(name)
-            break
-          }
-          case 'delete': {
-            const name = args[2]
-            if (!name) {
-              console.error('Error: project name is required')
-              process.exit(1)
-            }
-            await deleteProject(name)
-            break
-          }
-          default:
-            console.error(`Unknown project subcommand: ${subcommand ?? '(none)'}`)
-            console.log('Available: create, list, show, delete')
-            process.exit(1)
-        }
-        break
-      }
-
-      case 'keyword': {
-        const subcommand = args[1]
-        switch (subcommand) {
-          case 'add': {
-            const project = args[2]
-            const kws = args.slice(3)
-            if (!project || kws.length === 0) {
-              console.error('Error: project name and at least one keyword required')
-              process.exit(1)
-            }
-            await addKeywords(project, kws)
-            break
-          }
-          case 'list': {
-            const project = args[2]
-            if (!project) {
-              console.error('Error: project name is required')
-              process.exit(1)
-            }
-            await listKeywords(project)
-            break
-          }
-          case 'import': {
-            const project = args[2]
-            const filePath = args[3]
-            if (!project || !filePath) {
-              console.error('Error: project name and file path required')
-              process.exit(1)
-            }
-            await importKeywords(project, filePath)
-            break
-          }
-          default:
-            console.error(`Unknown keyword subcommand: ${subcommand ?? '(none)'}`)
-            console.log('Available: add, list, import')
-            process.exit(1)
-        }
-        break
-      }
-
-      case 'competitor': {
-        const subcommand = args[1]
-        switch (subcommand) {
-          case 'add': {
-            const project = args[2]
-            const domains = args.slice(3)
-            if (!project || domains.length === 0) {
-              console.error('Error: project name and at least one domain required')
-              process.exit(1)
-            }
-            await addCompetitors(project, domains)
-            break
-          }
-          case 'list': {
-            const project = args[2]
-            if (!project) {
-              console.error('Error: project name is required')
-              process.exit(1)
-            }
-            await listCompetitors(project)
-            break
-          }
-          default:
-            console.error(`Unknown competitor subcommand: ${subcommand ?? '(none)'}`)
-            console.log('Available: add, list')
-            process.exit(1)
-        }
-        break
-      }
-
-      case 'run': {
-        const project = args[1]
-        if (!project) {
-          console.error('Error: project name is required')
-          process.exit(1)
-        }
-        const runParsed = parseArgs({
-          args: args.slice(2),
-          options: {
-            provider: { type: 'string' },
-          },
-          allowPositionals: false,
-        })
-        await triggerRun(project, { provider: runParsed.values.provider })
-        break
-      }
-
-      case 'runs': {
-        const project = args[1]
-        if (!project) {
-          console.error('Error: project name is required')
-          process.exit(1)
-        }
-        await listRuns(project)
-        break
-      }
-
-      case 'status': {
-        const project = args[1]
-        if (!project) {
-          console.error('Error: project name is required')
-          process.exit(1)
-        }
-        await showStatus(project)
-        break
-      }
-
-      case 'evidence': {
-        const project = args[1]
-        if (!project) {
-          console.error('Error: project name is required')
-          process.exit(1)
-        }
-        await showEvidence(project)
-        break
-      }
-
-      case 'history': {
-        const project = args[1]
-        if (!project) {
-          console.error('Error: project name is required')
-          process.exit(1)
-        }
-        await showHistory(project)
-        break
-      }
-
-      case 'export': {
-        const project = args[1]
-        if (!project) {
-          console.error('Error: project name is required')
-          process.exit(1)
-        }
-        const includeResults = args.includes('--include-results')
-        await exportProject(project, { includeResults })
-        break
-      }
-
-      case 'apply': {
-        const filePath = args[1]
-        if (!filePath) {
-          console.error('Error: file path is required')
-          process.exit(1)
-        }
-        await applyConfig(filePath)
-        break
-      }
-
-      case 'schedule': {
-        const subcommand = args[1]
-        const schedProject = args[2]
-        if (!schedProject && subcommand !== undefined) {
-          console.error('Error: project name is required')
-          process.exit(1)
-        }
-        switch (subcommand) {
-          case 'set': {
-            const { values } = parseArgs({
-              args: args.slice(3),
-              options: {
-                preset: { type: 'string' },
-                cron: { type: 'string' },
-                timezone: { type: 'string' },
-                provider: { type: 'string', multiple: true },
-              },
-              allowPositionals: false,
-            })
-            if (!values.preset && !values.cron) {
-              console.error('Error: --preset or --cron is required')
-              process.exit(1)
-            }
-            await setSchedule(schedProject!, {
-              preset: values.preset,
-              cron: values.cron,
-              timezone: values.timezone,
-              providers: values.provider,
-            })
-            break
-          }
-          case 'show':
-            await showSchedule(schedProject!)
-            break
-          case 'enable':
-            await enableSchedule(schedProject!)
-            break
-          case 'disable':
-            await disableSchedule(schedProject!)
-            break
-          case 'remove':
-            await removeSchedule(schedProject!)
-            break
-          default:
-            console.error(`Unknown schedule subcommand: ${subcommand ?? '(none)'}`)
-            console.log('Available: set, show, enable, disable, remove')
-            process.exit(1)
-        }
-        break
-      }
-
-      case 'notify': {
-        const notifSubcommand = args[1]
-        const notifProject = args[2]
-        if (!notifProject && notifSubcommand !== undefined) {
-          console.error('Error: project name is required')
-          process.exit(1)
-        }
-        switch (notifSubcommand) {
-          case 'add': {
-            const { values } = parseArgs({
-              args: args.slice(3),
-              options: {
-                webhook: { type: 'string' },
-                events: { type: 'string' },
-              },
-              allowPositionals: false,
-            })
-            if (!values.webhook) {
-              console.error('Error: --webhook is required')
-              process.exit(1)
-            }
-            if (!values.events) {
-              console.error('Error: --events is required (comma-separated)')
-              process.exit(1)
-            }
-            await addNotification(notifProject!, {
-              webhook: values.webhook,
-              events: values.events.split(',').map(e => e.trim()),
-            })
-            break
-          }
-          case 'list':
-            await listNotifications(notifProject!)
-            break
-          case 'remove': {
-            const notifId = args[3]
-            if (!notifId) {
-              console.error('Error: notification ID is required')
-              process.exit(1)
-            }
-            await removeNotification(notifProject!, notifId)
-            break
-          }
-          case 'test': {
-            const testId = args[3]
-            if (!testId) {
-              console.error('Error: notification ID is required')
-              process.exit(1)
-            }
-            await testNotification(notifProject!, testId)
-            break
-          }
-          default:
-            console.error(`Unknown notify subcommand: ${notifSubcommand ?? '(none)'}`)
-            console.log('Available: add, list, remove, test')
-            process.exit(1)
-        }
-        break
-      }
-
-      case 'settings': {
-        const subcommand = args[1]
-        if (subcommand === 'provider') {
-          const name = args[2]
-          if (!name) {
-            console.error('Error: provider name is required (gemini, openai, claude, local)')
-            process.exit(1)
-          }
-          const { values } = parseArgs({
-            args: args.slice(3),
-            options: {
-              'api-key': { type: 'string' },
-              'base-url': { type: 'string' },
-              model: { type: 'string' },
-            },
-            allowPositionals: false,
-          })
-          if (name === 'local') {
-            if (!values['base-url']) {
-              console.error('Error: --base-url is required for the local provider')
-              process.exit(1)
-            }
-          } else {
-            if (!values['api-key']) {
-              console.error('Error: --api-key is required')
-              process.exit(1)
-            }
-          }
-          await setProvider(name, { apiKey: values['api-key'], baseUrl: values['base-url'], model: values.model })
-        } else {
-          await showSettings()
-        }
-        break
-      }
-
-      default:
-        console.error(`Unknown command: ${command}`)
-        console.log('Run "canonry --help" for usage.')
-        process.exit(1)
-    }
-  } catch (err: unknown) {
-    if (err instanceof Error) {
-      console.error(`Error: ${err.message}`)
-    } else {
-      console.error('An unexpected error occurred')
-    }
-    process.exit(1)
-  }
-}
-
-main()

package/src/client.ts

@@ -1,152 +0,0 @@
-export class ApiClient {
-  private baseUrl: string
-  private apiKey: string
-
-  constructor(baseUrl: string, apiKey: string) {
-    this.baseUrl = baseUrl.replace(/\/$/, '') + '/api/v1'
-    this.apiKey = apiKey
-  }
-
-  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
-    const url = `${this.baseUrl}${path}`
-    const headers: Record<string, string> = {
-      'Authorization': `Bearer ${this.apiKey}`,
-      'Content-Type': 'application/json',
-    }
-
-    const res = await fetch(url, {
-      method,
-      headers,
-      body: body != null ? JSON.stringify(body) : undefined,
-    })
-
-    if (!res.ok) {
-      let errorBody: unknown
-      try {
-        errorBody = await res.json()
-      } catch {
-        errorBody = { error: { code: 'UNKNOWN', message: res.statusText } }
-      }
-      const msg =
-        errorBody &&
-        typeof errorBody === 'object' &&
-        'error' in errorBody &&
-        errorBody.error &&
-        typeof errorBody.error === 'object' &&
-        'message' in errorBody.error
-          ? String((errorBody.error as { message: string }).message)
-          : `HTTP ${res.status}: ${res.statusText}`
-      throw new Error(msg)
-    }
-
-    if (res.status === 204) {
-      return undefined as T
-    }
-
-    return (await res.json()) as T
-  }
-
-  async putProject(name: string, body: object): Promise<object> {
-    return this.request<object>('PUT', `/projects/${encodeURIComponent(name)}`, body)
-  }
-
-  async listProjects(): Promise<object[]> {
-    return this.request<object[]>('GET', '/projects')
-  }
-
-  async getProject(name: string): Promise<object> {
-    return this.request<object>('GET', `/projects/${encodeURIComponent(name)}`)
-  }
-
-  async deleteProject(name: string): Promise<void> {
-    await this.request<void>('DELETE', `/projects/${encodeURIComponent(name)}`)
-  }
-
-  async putKeywords(project: string, keywords: string[]): Promise<void> {
-    await this.request<unknown>('PUT', `/projects/${encodeURIComponent(project)}/keywords`, { keywords })
-  }
-
-  async listKeywords(project: string): Promise<object[]> {
-    return this.request<object[]>('GET', `/projects/${encodeURIComponent(project)}/keywords`)
-  }
-
-  async appendKeywords(project: string, keywords: string[]): Promise<void> {
-    await this.request<unknown>('POST', `/projects/${encodeURIComponent(project)}/keywords`, { keywords })
-  }
-
-  async putCompetitors(project: string, competitors: string[]): Promise<void> {
-    await this.request<unknown>('PUT', `/projects/${encodeURIComponent(project)}/competitors`, { competitors })
-  }
-
-  async listCompetitors(project: string): Promise<object[]> {
-    return this.request<object[]>('GET', `/projects/${encodeURIComponent(project)}/competitors`)
-  }
-
-  async triggerRun(project: string, body?: Record<string, unknown>): Promise<object> {
-    return this.request<object>('POST', `/projects/${encodeURIComponent(project)}/runs`, body ?? {})
-  }
-
-  async listRuns(project: string): Promise<object[]> {
-    return this.request<object[]>('GET', `/projects/${encodeURIComponent(project)}/runs`)
-  }
-
-  async getRun(id: string): Promise<object> {
-    return this.request<object>('GET', `/runs/${encodeURIComponent(id)}`)
-  }
-
-  async getTimeline(project: string): Promise<object[]> {
-    return this.request<object[]>('GET', `/projects/${encodeURIComponent(project)}/timeline`)
-  }
-
-  async getHistory(project: string): Promise<object[]> {
-    return this.request<object[]>('GET', `/projects/${encodeURIComponent(project)}/history`)
-  }
-
-  async getExport(project: string): Promise<object> {
-    return this.request<object>('GET', `/projects/${encodeURIComponent(project)}/export`)
-  }
-
-  async apply(config: object): Promise<object> {
-    return this.request<object>('POST', '/apply', config)
-  }
-
-  async getStatus(project: string): Promise<object> {
-    return this.request<object>('GET', `/projects/${encodeURIComponent(project)}`)
-  }
-
-  async getSettings(): Promise<object> {
-    return this.request<object>('GET', '/settings')
-  }
-
-  async updateProvider(name: string, body: { apiKey?: string; baseUrl?: string; model?: string }): Promise<object> {
-    return this.request<object>('PUT', `/settings/providers/${encodeURIComponent(name)}`, body)
-  }
-
-  async putSchedule(project: string, body: object): Promise<object> {
-    return this.request<object>('PUT', `/projects/${encodeURIComponent(project)}/schedule`, body)
-  }
-
-  async getSchedule(project: string): Promise<object> {
-    return this.request<object>('GET', `/projects/${encodeURIComponent(project)}/schedule`)
-  }
-
-  async deleteSchedule(project: string): Promise<void> {
-    await this.request<void>('DELETE', `/projects/${encodeURIComponent(project)}/schedule`)
-  }
-
-  async createNotification(project: string, body: object): Promise<object> {
-    return this.request<object>('POST', `/projects/${encodeURIComponent(project)}/notifications`, body)
-  }
-
-  async listNotifications(project: string): Promise<object[]> {
-    return this.request<object[]>('GET', `/projects/${encodeURIComponent(project)}/notifications`)
-  }
-
-  async deleteNotification(project: string, id: string): Promise<void> {
-    await this.request<void>('DELETE', `/projects/${encodeURIComponent(project)}/notifications/${encodeURIComponent(id)}`)
-  }
-
-  async testNotification(project: string, id: string): Promise<object> {
-    return this.request<object>('POST', `/projects/${encodeURIComponent(project)}/notifications/${encodeURIComponent(id)}/test`)
-  }
-}

package/src/commands/apply.ts

@@ -1,25 +0,0 @@
-import fs from 'node:fs'
-import { parse } from 'yaml'
-import { loadConfig } from '../config.js'
-import { ApiClient } from '../client.js'
-
-export async function applyConfig(filePath: string): Promise<void> {
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`File not found: ${filePath}`)
-  }
-
-  const content = fs.readFileSync(filePath, 'utf-8')
-  const config = parse(content) as object
-
-  const clientConfig = loadConfig()
-  const client = new ApiClient(clientConfig.apiUrl, clientConfig.apiKey)
-
-  const result = await client.apply(config) as {
-    id: string
-    name: string
-    displayName: string
-    configRevision: number
-  }
-
-  console.log(`Applied config for "${result.name}" (revision ${result.configRevision})`)
-}

package/src/commands/competitor.ts

@@ -1,36 +0,0 @@
-import { loadConfig } from '../config.js'
-import { ApiClient } from '../client.js'
-
-function getClient(): ApiClient {
-  const config = loadConfig()
-  return new ApiClient(config.apiUrl, config.apiKey)
-}
-
-export async function addCompetitors(project: string, domains: string[]): Promise<void> {
-  // First get existing competitors, then put the combined list
-  const client = getClient()
-  const existing = await client.listCompetitors(project) as Array<{ domain: string }>
-  const existingDomains = existing.map(c => c.domain)
-  const allDomains = [...new Set([...existingDomains, ...domains])]
-  await client.putCompetitors(project, allDomains)
-  console.log(`Added ${domains.length} competitor(s) to "${project}".`)
-}
-
-export async function listCompetitors(project: string): Promise<void> {
-  const client = getClient()
-  const comps = await client.listCompetitors(project) as Array<{
-    id: string
-    domain: string
-    createdAt: string
-  }>
-
-  if (comps.length === 0) {
-    console.log(`No competitors found for "${project}".`)
-    return
-  }
-
-  console.log(`Competitors for "${project}" (${comps.length}):\n`)
-  for (const c of comps) {
-    console.log(`  ${c.domain}`)
-  }
-}