@ainyc/canonry 1.0.0

package/src/commands/apply.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,36 @@
+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}`)
+  }
+}

package/src/commands/evidence.ts

@@ -0,0 +1,41 @@
+import { loadConfig } from '../config.js'
+import { ApiClient } from '../client.js'
+
+type TimelineEntry = {
+  keyword: string
+  runs: {
+    runId: string
+    createdAt: string
+    citationState: string
+    transition: string
+  }[]
+}
+
+function getClient(): ApiClient {
+  const config = loadConfig()
+  return new ApiClient(config.apiUrl, config.apiKey)
+}
+
+export async function showEvidence(project: string): Promise<void> {
+  const client = getClient()
+  const timeline = await client.getTimeline(project) as TimelineEntry[]
+
+  if (timeline.length === 0) {
+    console.log('No keyword evidence yet. Trigger a run first with "canonry run".')
+    return
+  }
+
+  console.log(`Evidence: ${project}\n`)
+
+  for (const entry of timeline) {
+    const latest = entry.runs[entry.runs.length - 1]
+    if (!latest) continue
+    const state = latest.citationState === 'cited' ? '✓ cited' : '✗ not-cited'
+    const transition = latest.transition !== latest.citationState ? ` (${latest.transition})` : ''
+    console.log(`  ${state}${transition}  ${entry.keyword}`)
+  }
+
+  console.log(`\n  Keywords: ${timeline.length}`)
+  const cited = timeline.filter(e => e.runs[e.runs.length - 1]?.citationState === 'cited').length
+  console.log(`  Cited:    ${cited} / ${timeline.length}`)
+}

package/src/commands/export-cmd.ts

@@ -0,0 +1,40 @@
+import { stringify } from 'yaml'
+import { loadConfig } from '../config.js'
+import { ApiClient } from '../client.js'
+
+export async function exportProject(
+  project: string,
+  opts: { includeResults?: boolean },
+): Promise<void> {
+  const config = loadConfig()
+  const client = new ApiClient(config.apiUrl, config.apiKey)
+
+  const data = await client.getExport(project) as {
+    apiVersion: string
+    kind: string
+    metadata: { name: string; labels: Record<string, string> }
+    spec: {
+      displayName: string
+      canonicalDomain: string
+      country: string
+      language: string
+      keywords: string[]
+      competitors: string[]
+    }
+  }
+
+  if (opts.includeResults) {
+    // Fetch latest run data and include as annotation
+    try {
+      const runs = await client.listRuns(project) as Array<{ id: string }>
+      if (runs.length > 0) {
+        const latestRun = await client.getRun(runs[runs.length - 1]!.id)
+        ;(data as Record<string, unknown>).results = latestRun
+      }
+    } catch {
+      // Results not available, skip
+    }
+  }
+
+  console.log(stringify(data))
+}

package/src/commands/history.ts

@@ -0,0 +1,41 @@
+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 showHistory(project: string): Promise<void> {
+  const client = getClient()
+
+  try {
+    const entries = await client.getHistory(project) as Array<{
+      id: string
+      actor: string
+      action: string
+      entityType: string
+      entityId: string | null
+      createdAt: string
+    }>
+
+    if (entries.length === 0) {
+      console.log(`No audit history for "${project}".`)
+      return
+    }
+
+    console.log(`Audit history for "${project}" (${entries.length}):\n`)
+    console.log('  TIMESTAMP                ACTION              ENTITY TYPE  ACTOR')
+    console.log('  ───────────────────────  ──────────────────  ───────────  ─────')
+
+    for (const entry of entries) {
+      console.log(
+        `  ${entry.createdAt.padEnd(23)}  ${entry.action.padEnd(18)}  ${entry.entityType.padEnd(11)}  ${entry.actor}`,
+      )
+    }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    console.error(`Failed to fetch history: ${message}`)
+    process.exit(1)
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,122 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import readline from 'node:readline'
+import { getConfigDir, getConfigPath, configExists, saveConfig } from '../config.js'
+import type { CanonryConfig, ProviderConfigEntry } from '../config.js'
+import { createClient, migrate } from '@ainyc/canonry-db'
+import { apiKeys } from '@ainyc/canonry-db'
+import path from 'node:path'
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close()
+      resolve(answer.trim())
+    })
+  })
+}
+
+const DEFAULT_QUOTA = {
+  maxConcurrency: 2,
+  maxRequestsPerMinute: 10,
+  maxRequestsPerDay: 500,
+}
+
+export async function initCommand(): Promise<void> {
+  console.log('Initializing canonry...\n')
+
+  if (configExists()) {
+    console.log(`Config already exists at ${getConfigPath()}`)
+    console.log('To reinitialize, delete the config file first.')
+    return
+  }
+
+  // Create config directory
+  const configDir = getConfigDir()
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true })
+  }
+
+  // Prompt for provider API keys
+  const providers: CanonryConfig['providers'] = {}
+
+  console.log('Configure AI providers (at least one required):\n')
+
+  // Gemini
+  const geminiApiKey = await prompt('Gemini API key (press Enter to skip): ')
+  if (geminiApiKey) {
+    const geminiModel = await prompt('  Gemini model [gemini-2.5-flash]: ') || 'gemini-2.5-flash'
+    providers.gemini = { apiKey: geminiApiKey, model: geminiModel, quota: DEFAULT_QUOTA }
+  }
+
+  // OpenAI
+  const openaiApiKey = await prompt('OpenAI API key (press Enter to skip): ')
+  if (openaiApiKey) {
+    const openaiModel = await prompt('  OpenAI model [gpt-4o]: ') || 'gpt-4o'
+    providers.openai = { apiKey: openaiApiKey, model: openaiModel, quota: DEFAULT_QUOTA }
+  }
+
+  // Claude
+  const claudeApiKey = await prompt('Anthropic API key (press Enter to skip): ')
+  if (claudeApiKey) {
+    const claudeModel = await prompt('  Claude model [claude-sonnet-4-6]: ') || 'claude-sonnet-4-6'
+    providers.claude = { apiKey: claudeApiKey, model: claudeModel, quota: DEFAULT_QUOTA }
+  }
+
+  // Local LLM
+  console.log('\nLocal LLM (Ollama, LM Studio, llama.cpp, vLLM — any OpenAI-compatible API):')
+  const localBaseUrl = await prompt('Local LLM base URL (press Enter to skip, e.g. http://localhost:11434/v1): ')
+  if (localBaseUrl) {
+    const localModel = await prompt('  Model name [llama3]: ') || 'llama3'
+    const localApiKey = await prompt('  API key (press Enter if not needed): ') || undefined
+    providers.local = { baseUrl: localBaseUrl, apiKey: localApiKey, model: localModel, quota: DEFAULT_QUOTA }
+  }
+
+  // Validate at least one provider
+  const hasProvider = providers.gemini || providers.openai || providers.claude || providers.local
+  if (!hasProvider) {
+    console.error('\nAt least one provider is required.')
+    process.exit(1)
+  }
+
+  // Generate random API key for the local server
+  const rawApiKey = `cnry_${crypto.randomBytes(16).toString('hex')}`
+  const keyHash = crypto.createHash('sha256').update(rawApiKey).digest('hex')
+  const keyPrefix = rawApiKey.slice(0, 9)
+
+  // Database path
+  const databasePath = path.join(configDir, 'data.db')
+
+  // Create and migrate database
+  const db = createClient(databasePath)
+  migrate(db)
+
+  // Insert the API key
+  db.insert(apiKeys).values({
+    id: crypto.randomUUID(),
+    name: 'default',
+    keyHash,
+    keyPrefix,
+    scopes: '["*"]',
+    createdAt: new Date().toISOString(),
+  }).run()
+
+  // Save config
+  saveConfig({
+    apiUrl: 'http://localhost:4100',
+    database: databasePath,
+    apiKey: rawApiKey,
+    providers,
+  })
+
+  const providerNames = Object.keys(providers).join(', ')
+  console.log(`\nConfig saved to ${getConfigPath()}`)
+  console.log(`Database created at ${databasePath}`)
+  console.log(`API key: ${rawApiKey}`)
+  console.log(`Providers: ${providerNames}`)
+  console.log('\nRun "canonry serve" to start the server.')
+}

package/src/commands/keyword.ts

@@ -0,0 +1,54 @@
+import fs from 'node:fs'
+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 addKeywords(project: string, keywords: string[]): Promise<void> {
+  const client = getClient()
+  await client.appendKeywords(project, keywords)
+  console.log(`Added ${keywords.length} keyword(s) to "${project}".`)
+}
+
+export async function listKeywords(project: string): Promise<void> {
+  const client = getClient()
+  const kws = await client.listKeywords(project) as Array<{
+    id: string
+    keyword: string
+    createdAt: string
+  }>
+
+  if (kws.length === 0) {
+    console.log(`No keywords found for "${project}".`)
+    return
+  }
+
+  console.log(`Keywords for "${project}" (${kws.length}):\n`)
+  for (const kw of kws) {
+    console.log(`  ${kw.keyword}`)
+  }
+}
+
+export async function importKeywords(project: string, filePath: string): Promise<void> {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`)
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8')
+  const keywords = content
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.length > 0 && !line.startsWith('#'))
+
+  if (keywords.length === 0) {
+    console.log('No keywords found in file.')
+    return
+  }
+
+  const client = getClient()
+  await client.appendKeywords(project, keywords)
+  console.log(`Imported ${keywords.length} keyword(s) to "${project}".`)
+}

package/src/commands/notify.ts

@@ -0,0 +1,70 @@
+import { loadConfig } from '../config.js'
+import { ApiClient } from '../client.js'
+
+function getClient(): ApiClient {
+  const config = loadConfig()
+  return new ApiClient(config.apiUrl, config.apiKey)
+}
+
+interface NotificationResponse {
+  id: string
+  projectId: string
+  channel: string
+  url: string
+  events: string[]
+  enabled: boolean
+}
+
+export async function addNotification(project: string, opts: {
+  webhook: string
+  events: string[]
+}): Promise<void> {
+  const client = getClient()
+  const result = await client.createNotification(project, {
+    channel: 'webhook',
+    url: opts.webhook,
+    events: opts.events,
+  }) as NotificationResponse
+
+  console.log(`Notification created for "${project}":`)
+  printNotification(result)
+}
+
+export async function listNotifications(project: string): Promise<void> {
+  const client = getClient()
+  const results = await client.listNotifications(project) as NotificationResponse[]
+  if (results.length === 0) {
+    console.log(`No notifications configured for "${project}"`)
+    return
+  }
+
+  console.log(`Notifications for "${project}":\n`)
+  for (const n of results) {
+    printNotification(n)
+    console.log()
+  }
+}
+
+export async function removeNotification(project: string, id: string): Promise<void> {
+  const client = getClient()
+  await client.deleteNotification(project, id)
+  console.log(`Notification ${id} removed from "${project}"`)
+}
+
+export async function testNotification(project: string, id: string): Promise<void> {
+  const client = getClient()
+  const result = await client.testNotification(project, id) as { status: number; ok: boolean }
+  if (result.ok) {
+    console.log(`Test webhook delivered successfully (HTTP ${result.status})`)
+  } else {
+    console.error(`Test webhook failed: HTTP ${result.status}`)
+  }
+}
+
+function printNotification(n: NotificationResponse): void {
+  console.log(`  ID:      ${n.id}`)
+  console.log(`  Channel: ${n.channel}`)
+  console.log(`  URL:     ${n.url}`)
+  console.log(`  Events:  ${n.events.join(', ')}`)
+  console.log(`  Enabled: ${n.enabled ? 'yes' : 'no'}`)
+}

package/src/commands/project.ts

@@ -0,0 +1,89 @@
+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 createProject(
+  name: string,
+  opts: { domain: string; country: string; language: string; displayName: string },
+): Promise<void> {
+  const client = getClient()
+  const result = await client.putProject(name, {
+    displayName: opts.displayName,
+    canonicalDomain: opts.domain,
+    country: opts.country,
+    language: opts.language,
+  }) as { id: string; name: string }
+  console.log(`Project created: ${result.name} (${result.id})`)
+}
+
+export async function listProjects(): Promise<void> {
+  const client = getClient()
+  const projects = await client.listProjects() as Array<{
+    name: string
+    canonicalDomain: string
+    country: string
+    language: string
+  }>
+
+  if (projects.length === 0) {
+    console.log('No projects found.')
+    return
+  }
+
+  console.log('Projects:\n')
+  const nameWidth = Math.max(4, ...projects.map(p => p.name.length))
+  const domainWidth = Math.max(6, ...projects.map(p => p.canonicalDomain.length))
+
+  console.log(
+    `  ${'NAME'.padEnd(nameWidth)}  ${'DOMAIN'.padEnd(domainWidth)}  COUNTRY  LANGUAGE`,
+  )
+  console.log(`  ${'─'.repeat(nameWidth)}  ${'─'.repeat(domainWidth)}  ───────  ────────`)
+
+  for (const p of projects) {
+    console.log(
+      `  ${p.name.padEnd(nameWidth)}  ${p.canonicalDomain.padEnd(domainWidth)}  ${p.country.padEnd(7)}  ${p.language}`,
+    )
+  }
+}
+
+export async function showProject(name: string): Promise<void> {
+  const client = getClient()
+  const project = await client.getProject(name) as {
+    id: string
+    name: string
+    displayName: string
+    canonicalDomain: string
+    country: string
+    language: string
+    tags: string[]
+    labels: Record<string, string>
+    configSource: string
+    configRevision: number
+    createdAt: string
+    updatedAt: string
+  }
+
+  console.log(`Project: ${project.displayName}\n`)
+  console.log(`  Name:             ${project.name}`)
+  console.log(`  ID:               ${project.id}`)
+  console.log(`  Domain:           ${project.canonicalDomain}`)
+  console.log(`  Country:          ${project.country}`)
+  console.log(`  Language:         ${project.language}`)
+  console.log(`  Config source:    ${project.configSource}`)
+  console.log(`  Config revision:  ${project.configRevision}`)
+  console.log(`  Tags:             ${project.tags.length > 0 ? project.tags.join(', ') : '(none)'}`)
+  const labelEntries = Object.entries(project.labels)
+  console.log(`  Labels:           ${labelEntries.length > 0 ? labelEntries.map(([k, v]) => `${k}=${v}`).join(', ') : '(none)'}`)
+  console.log(`  Created:          ${project.createdAt}`)
+  console.log(`  Updated:          ${project.updatedAt}`)
+}
+
+export async function deleteProject(name: string): Promise<void> {
+  const client = getClient()
+  await client.deleteProject(name)
+  console.log(`Project deleted: ${name}`)
+}

package/src/commands/run.ts

@@ -0,0 +1,54 @@
+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 triggerRun(project: string, opts?: { provider?: string }): Promise<void> {
+  const client = getClient()
+  const body: Record<string, unknown> = {}
+  if (opts?.provider) {
+    body.providers = [opts.provider]
+  }
+  const run = await client.triggerRun(project, body) as {
+    id: string
+    status: string
+    kind: string
+  }
+  console.log(`Run created: ${run.id}`)
+  console.log(`  Kind:   ${run.kind}`)
+  console.log(`  Status: ${run.status}`)
+  if (opts?.provider) {
+    console.log(`  Provider: ${opts.provider}`)
+  }
+}
+
+export async function listRuns(project: string): Promise<void> {
+  const client = getClient()
+  const runs = await client.listRuns(project) as Array<{
+    id: string
+    status: string
+    kind: string
+    trigger: string
+    startedAt: string | null
+    finishedAt: string | null
+    createdAt: string
+  }>
+
+  if (runs.length === 0) {
+    console.log(`No runs found for "${project}".`)
+    return
+  }
+
+  console.log(`Runs for "${project}" (${runs.length}):\n`)
+  console.log('  ID                                    STATUS      KIND                TRIGGER    CREATED')
+  console.log('  ────────────────────────────────────  ──────────  ──────────────────  ─────────  ───────────────────────')
+
+  for (const run of runs) {
+    console.log(
+      `  ${run.id}  ${run.status.padEnd(10)}  ${run.kind.padEnd(18)}  ${run.trigger.padEnd(9)}  ${run.createdAt}`,
+    )
+  }
+}

package/src/commands/schedule.ts

@@ -0,0 +1,90 @@
+import { loadConfig } from '../config.js'
+import { ApiClient } from '../client.js'
+
+function getClient(): ApiClient {
+  const config = loadConfig()
+  return new ApiClient(config.apiUrl, config.apiKey)
+}
+
+interface ScheduleResponse {
+  id: string
+  projectId: string
+  cronExpr: string
+  preset: string | null
+  timezone: string
+  enabled: boolean
+  providers: string[]
+  lastRunAt: string | null
+  nextRunAt: string | null
+}
+
+export async function setSchedule(project: string, opts: {
+  preset?: string
+  cron?: string
+  timezone?: string
+  providers?: string[]
+}): Promise<void> {
+  const client = getClient()
+  const body: Record<string, unknown> = {}
+  if (opts.preset) body.preset = opts.preset
+  if (opts.cron) body.cron = opts.cron
+  if (opts.timezone) body.timezone = opts.timezone
+  if (opts.providers?.length) body.providers = opts.providers
+
+  const result = await client.putSchedule(project, body) as ScheduleResponse
+  console.log(`Schedule set for "${project}":`)
+  printSchedule(result)
+}
+
+export async function showSchedule(project: string): Promise<void> {
+  const client = getClient()
+  const result = await client.getSchedule(project) as ScheduleResponse
+  printSchedule(result)
+}
+
+export async function enableSchedule(project: string): Promise<void> {
+  const client = getClient()
+  const current = await client.getSchedule(project) as ScheduleResponse
+  const body: Record<string, unknown> = { timezone: current.timezone }
+  if (current.preset) body.preset = current.preset
+  else body.cron = current.cronExpr
+  if (current.providers.length) body.providers = current.providers
+
+  await client.putSchedule(project, body)
+  console.log(`Schedule enabled for "${project}"`)
+}
+
+export async function disableSchedule(project: string): Promise<void> {
+  const client = getClient()
+  const current = await client.getSchedule(project) as ScheduleResponse
+  const body: Record<string, unknown> = { timezone: current.timezone, enabled: false }
+  if (current.preset) body.preset = current.preset
+  else body.cron = current.cronExpr
+  if (current.providers.length) body.providers = current.providers
+
+  await client.putSchedule(project, body)
+  console.log(`Schedule disabled for "${project}"`)
+}
+
+export async function removeSchedule(project: string): Promise<void> {
+  const client = getClient()
+  await client.deleteSchedule(project)
+  console.log(`Schedule removed for "${project}"`)
+}
+
+function printSchedule(s: ScheduleResponse): void {
+  const label = s.preset ?? s.cronExpr
+  console.log(`  Schedule:  ${label}`)
+  console.log(`  Cron:      ${s.cronExpr}`)
+  console.log(`  Timezone:  ${s.timezone}`)
+  console.log(`  Enabled:   ${s.enabled ? 'yes' : 'no'}`)
+  if (s.providers.length) {
+    console.log(`  Providers: ${s.providers.join(', ')}`)
+  }
+  if (s.lastRunAt) {
+    console.log(`  Last run:  ${s.lastRunAt}`)
+  }
+  if (s.nextRunAt) {
+    console.log(`  Next run:  ${s.nextRunAt}`)
+  }
+}

package/src/commands/serve.ts

@@ -0,0 +1,24 @@
+import { loadConfig } from '../config.js'
+import { createClient, migrate } from '@ainyc/canonry-db'
+import { createServer } from '../server.js'
+
+export async function serveCommand(): Promise<void> {
+  const config = loadConfig()
+  const port = parseInt(process.env.CANONRY_PORT ?? '4100', 10)
+
+  // Create DB client and run migrations
+  const db = createClient(config.database)
+  migrate(db)
+
+  // Create and start server
+  const app = await createServer({ config, db })
+
+  try {
+    await app.listen({ host: '0.0.0.0', port })
+    console.log(`\nCanonry server running at http://localhost:${port}`)
+    console.log('Press Ctrl+C to stop.\n')
+  } catch (err) {
+    app.log.error(err)
+    process.exit(1)
+  }
+}