@ainyc/canonry 1.0.0

package/dist/cli.js

@@ -0,0 +1,1101 @@
+#!/usr/bin/env node --import tsx
+import {
+  apiKeys,
+  configExists,
+  createClient,
+  createServer,
+  getConfigDir,
+  getConfigPath,
+  loadConfig,
+  migrate,
+  saveConfig
+} from "./chunk-ONZDY6Q4.js";
+
+// src/cli.ts
+import { parseArgs } from "util";
+
+// src/commands/init.ts
+import crypto from "crypto";
+import fs from "fs";
+import readline from "readline";
+import path from "path";
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+var DEFAULT_QUOTA = {
+  maxConcurrency: 2,
+  maxRequestsPerMinute: 10,
+  maxRequestsPerDay: 500
+};
+async function initCommand() {
+  console.log("Initializing canonry...\n");
+  if (configExists()) {
+    console.log(`Config already exists at ${getConfigPath()}`);
+    console.log("To reinitialize, delete the config file first.");
+    return;
+  }
+  const configDir = getConfigDir();
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  const providers = {};
+  console.log("Configure AI providers (at least one required):\n");
+  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 };
+  }
+  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 };
+  }
+  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 };
+  }
+  console.log("\nLocal LLM (Ollama, LM Studio, llama.cpp, vLLM \u2014 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): ") || void 0;
+    providers.local = { baseUrl: localBaseUrl, apiKey: localApiKey, model: localModel, quota: DEFAULT_QUOTA };
+  }
+  const hasProvider = providers.gemini || providers.openai || providers.claude || providers.local;
+  if (!hasProvider) {
+    console.error("\nAt least one provider is required.");
+    process.exit(1);
+  }
+  const rawApiKey = `cnry_${crypto.randomBytes(16).toString("hex")}`;
+  const keyHash = crypto.createHash("sha256").update(rawApiKey).digest("hex");
+  const keyPrefix = rawApiKey.slice(0, 9);
+  const databasePath = path.join(configDir, "data.db");
+  const db = createClient(databasePath);
+  migrate(db);
+  db.insert(apiKeys).values({
+    id: crypto.randomUUID(),
+    name: "default",
+    keyHash,
+    keyPrefix,
+    scopes: '["*"]',
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).run();
+  saveConfig({
+    apiUrl: "http://localhost:4100",
+    database: databasePath,
+    apiKey: rawApiKey,
+    providers
+  });
+  const providerNames = Object.keys(providers).join(", ");
+  console.log(`
+Config 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.');
+}
+
+// src/commands/serve.ts
+async function serveCommand() {
+  const config = loadConfig();
+  const port = parseInt(process.env.CANONRY_PORT ?? "4100", 10);
+  const db = createClient(config.database);
+  migrate(db);
+  const app = await createServer({ config, db });
+  try {
+    await app.listen({ host: "0.0.0.0", port });
+    console.log(`
+Canonry server running at http://localhost:${port}`);
+    console.log("Press Ctrl+C to stop.\n");
+  } catch (err) {
+    app.log.error(err);
+    process.exit(1);
+  }
+}
+
+// src/client.ts
+var ApiClient = class {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl.replace(/\/$/, "") + "/api/v1";
+    this.apiKey = apiKey;
+  }
+  async request(method, path2, body) {
+    const url = `${this.baseUrl}${path2}`;
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body != null ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      let errorBody;
+      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.message) : `HTTP ${res.status}: ${res.statusText}`;
+      throw new Error(msg);
+    }
+    if (res.status === 204) {
+      return void 0;
+    }
+    return await res.json();
+  }
+  async putProject(name, body) {
+    return this.request("PUT", `/projects/${encodeURIComponent(name)}`, body);
+  }
+  async listProjects() {
+    return this.request("GET", "/projects");
+  }
+  async getProject(name) {
+    return this.request("GET", `/projects/${encodeURIComponent(name)}`);
+  }
+  async deleteProject(name) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(name)}`);
+  }
+  async putKeywords(project, keywords) {
+    await this.request("PUT", `/projects/${encodeURIComponent(project)}/keywords`, { keywords });
+  }
+  async listKeywords(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/keywords`);
+  }
+  async appendKeywords(project, keywords) {
+    await this.request("POST", `/projects/${encodeURIComponent(project)}/keywords`, { keywords });
+  }
+  async putCompetitors(project, competitors) {
+    await this.request("PUT", `/projects/${encodeURIComponent(project)}/competitors`, { competitors });
+  }
+  async listCompetitors(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/competitors`);
+  }
+  async triggerRun(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/runs`, body ?? {});
+  }
+  async listRuns(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/runs`);
+  }
+  async getRun(id) {
+    return this.request("GET", `/runs/${encodeURIComponent(id)}`);
+  }
+  async getTimeline(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/timeline`);
+  }
+  async getHistory(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/history`);
+  }
+  async getExport(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/export`);
+  }
+  async apply(config) {
+    return this.request("POST", "/apply", config);
+  }
+  async getStatus(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}`);
+  }
+  async getSettings() {
+    return this.request("GET", "/settings");
+  }
+  async updateProvider(name, body) {
+    return this.request("PUT", `/settings/providers/${encodeURIComponent(name)}`, body);
+  }
+  async putSchedule(project, body) {
+    return this.request("PUT", `/projects/${encodeURIComponent(project)}/schedule`, body);
+  }
+  async getSchedule(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/schedule`);
+  }
+  async deleteSchedule(project) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/schedule`);
+  }
+  async createNotification(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/notifications`, body);
+  }
+  async listNotifications(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/notifications`);
+  }
+  async deleteNotification(project, id) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/notifications/${encodeURIComponent(id)}`);
+  }
+  async testNotification(project, id) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/notifications/${encodeURIComponent(id)}/test`);
+  }
+};
+
+// src/commands/project.ts
+function getClient() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function createProject(name, opts) {
+  const client = getClient();
+  const result = await client.putProject(name, {
+    displayName: opts.displayName,
+    canonicalDomain: opts.domain,
+    country: opts.country,
+    language: opts.language
+  });
+  console.log(`Project created: ${result.name} (${result.id})`);
+}
+async function listProjects() {
+  const client = getClient();
+  const projects = await client.listProjects();
+  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(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(domainWidth)}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  for (const p of projects) {
+    console.log(
+      `  ${p.name.padEnd(nameWidth)}  ${p.canonicalDomain.padEnd(domainWidth)}  ${p.country.padEnd(7)}  ${p.language}`
+    );
+  }
+}
+async function showProject(name) {
+  const client = getClient();
+  const project = await client.getProject(name);
+  console.log(`Project: ${project.displayName}
+`);
+  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}`);
+}
+async function deleteProject(name) {
+  const client = getClient();
+  await client.deleteProject(name);
+  console.log(`Project deleted: ${name}`);
+}
+
+// src/commands/keyword.ts
+import fs2 from "fs";
+function getClient2() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function addKeywords(project, keywords) {
+  const client = getClient2();
+  await client.appendKeywords(project, keywords);
+  console.log(`Added ${keywords.length} keyword(s) to "${project}".`);
+}
+async function listKeywords(project) {
+  const client = getClient2();
+  const kws = await client.listKeywords(project);
+  if (kws.length === 0) {
+    console.log(`No keywords found for "${project}".`);
+    return;
+  }
+  console.log(`Keywords for "${project}" (${kws.length}):
+`);
+  for (const kw of kws) {
+    console.log(`  ${kw.keyword}`);
+  }
+}
+async function importKeywords(project, filePath) {
+  if (!fs2.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const content = fs2.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 = getClient2();
+  await client.appendKeywords(project, keywords);
+  console.log(`Imported ${keywords.length} keyword(s) to "${project}".`);
+}
+
+// src/commands/competitor.ts
+function getClient3() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function addCompetitors(project, domains) {
+  const client = getClient3();
+  const existing = await client.listCompetitors(project);
+  const existingDomains = existing.map((c) => c.domain);
+  const allDomains = [.../* @__PURE__ */ new Set([...existingDomains, ...domains])];
+  await client.putCompetitors(project, allDomains);
+  console.log(`Added ${domains.length} competitor(s) to "${project}".`);
+}
+async function listCompetitors(project) {
+  const client = getClient3();
+  const comps = await client.listCompetitors(project);
+  if (comps.length === 0) {
+    console.log(`No competitors found for "${project}".`);
+    return;
+  }
+  console.log(`Competitors for "${project}" (${comps.length}):
+`);
+  for (const c of comps) {
+    console.log(`  ${c.domain}`);
+  }
+}
+
+// src/commands/run.ts
+function getClient4() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function triggerRun(project, opts) {
+  const client = getClient4();
+  const body = {};
+  if (opts?.provider) {
+    body.providers = [opts.provider];
+  }
+  const run = await client.triggerRun(project, body);
+  console.log(`Run created: ${run.id}`);
+  console.log(`  Kind:   ${run.kind}`);
+  console.log(`  Status: ${run.status}`);
+  if (opts?.provider) {
+    console.log(`  Provider: ${opts.provider}`);
+  }
+}
+async function listRuns(project) {
+  const client = getClient4();
+  const runs = await client.listRuns(project);
+  if (runs.length === 0) {
+    console.log(`No runs found for "${project}".`);
+    return;
+  }
+  console.log(`Runs for "${project}" (${runs.length}):
+`);
+  console.log("  ID                                    STATUS      KIND                TRIGGER    CREATED");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const run of runs) {
+    console.log(
+      `  ${run.id}  ${run.status.padEnd(10)}  ${run.kind.padEnd(18)}  ${run.trigger.padEnd(9)}  ${run.createdAt}`
+    );
+  }
+}
+
+// src/commands/status.ts
+function getClient5() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function showStatus(project) {
+  const client = getClient5();
+  const projectData = await client.getProject(project);
+  console.log(`Status: ${projectData.displayName} (${projectData.name})
+`);
+  console.log(`  Domain:   ${projectData.canonicalDomain}`);
+  console.log(`  Country:  ${projectData.country}`);
+  console.log(`  Language: ${projectData.language}`);
+  try {
+    const runs = await client.listRuns(project);
+    if (runs.length > 0) {
+      const latest = runs[runs.length - 1];
+      console.log(`
+  Latest run:`);
+      console.log(`    ID:       ${latest.id}`);
+      console.log(`    Status:   ${latest.status}`);
+      console.log(`    Created:  ${latest.createdAt}`);
+      if (latest.finishedAt) {
+        console.log(`    Finished: ${latest.finishedAt}`);
+      }
+      console.log(`
+  Total runs: ${runs.length}`);
+    } else {
+      console.log('\n  No runs yet. Use "canonry run" to trigger one.');
+    }
+  } catch {
+    console.log("\n  Run info unavailable.");
+  }
+}
+
+// src/commands/evidence.ts
+function getClient6() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function showEvidence(project) {
+  const client = getClient6();
+  const timeline = await client.getTimeline(project);
+  if (timeline.length === 0) {
+    console.log('No keyword evidence yet. Trigger a run first with "canonry run".');
+    return;
+  }
+  console.log(`Evidence: ${project}
+`);
+  for (const entry of timeline) {
+    const latest = entry.runs[entry.runs.length - 1];
+    if (!latest) continue;
+    const state = latest.citationState === "cited" ? "\u2713 cited" : "\u2717 not-cited";
+    const transition = latest.transition !== latest.citationState ? ` (${latest.transition})` : "";
+    console.log(`  ${state}${transition}  ${entry.keyword}`);
+  }
+  console.log(`
+  Keywords: ${timeline.length}`);
+  const cited = timeline.filter((e) => e.runs[e.runs.length - 1]?.citationState === "cited").length;
+  console.log(`  Cited:    ${cited} / ${timeline.length}`);
+}
+
+// src/commands/history.ts
+function getClient7() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function showHistory(project) {
+  const client = getClient7();
+  try {
+    const entries = await client.getHistory(project);
+    if (entries.length === 0) {
+      console.log(`No audit history for "${project}".`);
+      return;
+    }
+    console.log(`Audit history for "${project}" (${entries.length}):
+`);
+    console.log("  TIMESTAMP                ACTION              ENTITY TYPE  ACTOR");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500");
+    for (const entry of entries) {
+      console.log(
+        `  ${entry.createdAt.padEnd(23)}  ${entry.action.padEnd(18)}  ${entry.entityType.padEnd(11)}  ${entry.actor}`
+      );
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to fetch history: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/apply.ts
+import fs3 from "fs";
+import { parse } from "yaml";
+async function applyConfig(filePath) {
+  if (!fs3.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const config = parse(content);
+  const clientConfig = loadConfig();
+  const client = new ApiClient(clientConfig.apiUrl, clientConfig.apiKey);
+  const result = await client.apply(config);
+  console.log(`Applied config for "${result.name}" (revision ${result.configRevision})`);
+}
+
+// src/commands/export-cmd.ts
+import { stringify } from "yaml";
+async function exportProject(project, opts) {
+  const config = loadConfig();
+  const client = new ApiClient(config.apiUrl, config.apiKey);
+  const data = await client.getExport(project);
+  if (opts.includeResults) {
+    try {
+      const runs = await client.listRuns(project);
+      if (runs.length > 0) {
+        const latestRun = await client.getRun(runs[runs.length - 1].id);
+        data.results = latestRun;
+      }
+    } catch {
+    }
+  }
+  console.log(stringify(data));
+}
+
+// src/commands/settings.ts
+function getClient8() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function setProvider(name, opts) {
+  const client = getClient8();
+  const result = await client.updateProvider(name, opts);
+  console.log(`Provider ${result.name} updated successfully.`);
+  if (result.model) {
+    console.log(`  Model: ${result.model}`);
+  }
+}
+async function showSettings() {
+  const client = getClient8();
+  const settings = await client.getSettings();
+  console.log("Provider settings:\n");
+  for (const provider of settings.providers) {
+    const status = provider.configured ? "configured" : "not configured";
+    console.log(`  ${provider.name.padEnd(10)} ${status}`);
+    if (provider.configured) {
+      console.log(`    Model:     ${provider.model ?? "(default)"}`);
+      if (provider.quota) {
+        console.log(`    Quota:     ${provider.quota.maxConcurrency} concurrent \xB7 ${provider.quota.maxRequestsPerMinute}/min \xB7 ${provider.quota.maxRequestsPerDay}/day`);
+      }
+    }
+  }
+}
+
+// src/commands/schedule.ts
+function getClient9() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function setSchedule(project, opts) {
+  const client = getClient9();
+  const body = {};
+  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);
+  console.log(`Schedule set for "${project}":`);
+  printSchedule(result);
+}
+async function showSchedule(project) {
+  const client = getClient9();
+  const result = await client.getSchedule(project);
+  printSchedule(result);
+}
+async function enableSchedule(project) {
+  const client = getClient9();
+  const current = await client.getSchedule(project);
+  const body = { 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}"`);
+}
+async function disableSchedule(project) {
+  const client = getClient9();
+  const current = await client.getSchedule(project);
+  const body = { 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}"`);
+}
+async function removeSchedule(project) {
+  const client = getClient9();
+  await client.deleteSchedule(project);
+  console.log(`Schedule removed for "${project}"`);
+}
+function printSchedule(s) {
+  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}`);
+  }
+}
+
+// src/commands/notify.ts
+function getClient10() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function addNotification(project, opts) {
+  const client = getClient10();
+  const result = await client.createNotification(project, {
+    channel: "webhook",
+    url: opts.webhook,
+    events: opts.events
+  });
+  console.log(`Notification created for "${project}":`);
+  printNotification(result);
+}
+async function listNotifications(project) {
+  const client = getClient10();
+  const results = await client.listNotifications(project);
+  if (results.length === 0) {
+    console.log(`No notifications configured for "${project}"`);
+    return;
+  }
+  console.log(`Notifications for "${project}":
+`);
+  for (const n of results) {
+    printNotification(n);
+    console.log();
+  }
+}
+async function removeNotification(project, id) {
+  const client = getClient10();
+  await client.deleteNotification(project, id);
+  console.log(`Notification ${id} removed from "${project}"`);
+}
+async function testNotification(project, id) {
+  const client = getClient10();
+  const result = await client.testNotification(project, id);
+  if (result.ok) {
+    console.log(`Test webhook delivered successfully (HTTP ${result.status})`);
+  } else {
+    console.error(`Test webhook failed: HTTP ${result.status}`);
+  }
+}
+function printNotification(n) {
+  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"}`);
+}
+
+// src/cli.ts
+var USAGE = `
+canonry \u2014 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();
+var 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 !== void 0) {
+          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 !== void 0) {
+          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) {
+    if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+    } else {
+      console.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+main();