contentkong 0.1.0

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "contentkong",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "ckx": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outfile dist/index.js --target node",
+    "dev": "bun run src/index.ts"
+  },
+  "dependencies": {
+    "@contentkong/shared": "workspace:*",
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,75 @@
+type HttpMethod = "GET" | "POST" | "DELETE";
+
+interface ClientConfig {
+  apiKey?: string;
+  apiUrl?: string;
+}
+
+let globalConfig: ClientConfig = {};
+
+export function configureClient(config: ClientConfig): void {
+  globalConfig = config;
+}
+
+function getApiKey(): string {
+  const key = globalConfig.apiKey || process.env.CK_API_KEY;
+  if (!key) {
+    console.error("Error: API key required. Set CK_API_KEY or use --api-key.");
+    process.exit(1);
+  }
+  return key;
+}
+
+function getBaseUrl(): string {
+  return (
+    globalConfig.apiUrl ||
+    process.env.CK_API_URL ||
+    "https://api.contentkong.com"
+  );
+}
+
+async function request<T = unknown>(
+  method: HttpMethod,
+  path: string,
+  body?: unknown,
+): Promise<T> {
+  const url = `${getBaseUrl()}${path}`;
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${getApiKey()}`,
+    "Content-Type": "application/json",
+  };
+
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  if (!res.ok) {
+    let msg = `HTTP ${res.status}`;
+    try {
+      const err = (await res.json()) as { error?: string; message?: string };
+      msg = err.error || err.message || msg;
+    } catch {
+      // ignore parse failure
+    }
+    throw new Error(msg);
+  }
+
+  // handle 204 no content
+  if (res.status === 204) return undefined as T;
+
+  return (await res.json()) as T;
+}
+
+export function apiGet<T = unknown>(path: string): Promise<T> {
+  return request<T>("GET", path);
+}
+
+export function apiPost<T = unknown>(path: string, body?: unknown): Promise<T> {
+  return request<T>("POST", path, body);
+}
+
+export function apiDelete<T = unknown>(path: string): Promise<T> {
+  return request<T>("DELETE", path);
+}

package/src/commands/export.ts

@@ -0,0 +1,36 @@
+import { writeFile } from "node:fs/promises";
+import { Command } from "commander";
+import { apiGet } from "../client.js";
+export const exportCommand = new Command("export")
+  .description("Export article content to file or stdout")
+  .argument("<articleId>", "Article ID")
+  .option("--format <format>", "Output format: markdown|json", "markdown")
+  .option("--output <path>", "Write to file instead of stdout")
+  .action(async (articleId: string, opts) => {
+    try {
+      const data = await apiGet<{ content?: unknown[]; contentMarkdown?: string }>(
+        `/v1/articles/${articleId}/content`,
+      );
+
+      let output: string;
+      switch (opts.format) {
+        case "json":
+          output = JSON.stringify(data.content ?? [], null, 2);
+          break;
+        case "markdown":
+        default:
+          output = data.contentMarkdown ?? "";
+          break;
+      }
+
+      if (opts.output) {
+        await writeFile(opts.output, output, "utf-8");
+        console.log(`Written to ${opts.output}`);
+      } else {
+        console.log(output);
+      }
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/generate.ts

@@ -0,0 +1,64 @@
+import { Command } from "commander";
+import { apiGet, apiPost } from "../client.js";
+import type { Article } from "@contentkong/shared";
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+export const generateCommand = new Command("generate")
+  .description("Generate a new article")
+  .requiredOption("--topic <topic>", "Article topic")
+  .requiredOption("--site <siteId>", "Site ID")
+  .option("--type <type>", "Article type", "blog_post")
+  .option("--length <length>", "Article length", "medium")
+  .option("--voice <voiceId>", "Voice ID")
+  .option("--keyword <keywords...>", "Target keywords")
+  .option("--wait", "Wait for completion")
+  .action(async (opts) => {
+    try {
+      const body: Record<string, unknown> = {
+        topic: opts.topic,
+        siteId: opts.site,
+        type: opts.type,
+        length: opts.length,
+      };
+      if (opts.voice) body.voiceId = opts.voice;
+      if (opts.keyword) body.keyword = opts.keyword[0];
+
+      const article = await apiPost<Article>("/v1/articles", body);
+      console.log(`Article created: ${article.id}`);
+      console.log(`Status: ${article.status}`);
+
+      if (!opts.wait) return;
+
+      let prev = article.status;
+      console.log(`Waiting for completion...`);
+
+      while (true) {
+        await sleep(3000);
+        const current = await apiGet<Article>(`/v1/articles/${article.id}`);
+
+        if (current.status !== prev) {
+          console.log(`Phase: ${current.status}`);
+          prev = current.status;
+        }
+
+        if (current.status === "completed") {
+          console.log(`\nCompleted!`);
+          console.log(`Title: ${current.title ?? current.topic}`);
+          console.log(`Words: ${current.wordCount}`);
+          console.log(`ID: ${current.id}`);
+          return;
+        }
+
+        if (current.status === "failed") {
+          console.error(`\nArticle generation failed.`);
+          process.exit(1);
+        }
+      }
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/get.ts

@@ -0,0 +1,27 @@
+import { Command } from "commander";
+import { apiGet } from "../client.js";
+
+export const getCommand = new Command("get")
+  .description("Get article content")
+  .argument("<articleId>", "Article ID")
+  .option("--format <format>", "Output format: json|markdown|html", "markdown")
+  .action(async (articleId: string, opts) => {
+    try {
+      const data = await apiGet<{ content?: unknown[]; contentMarkdown?: string }>(
+        `/v1/articles/${articleId}/content`,
+      );
+
+      switch (opts.format) {
+        case "json":
+          console.log(JSON.stringify(data.content ?? [], null, 2));
+          break;
+        case "markdown":
+        default:
+          console.log(data.contentMarkdown ?? "");
+          break;
+      }
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/list.ts

@@ -0,0 +1,53 @@
+import { Command } from "commander";
+import { apiGet } from "../client.js";
+import type { Article } from "@contentkong/shared";
+
+function truncate(s: string, len: number): string {
+  return s.length > len ? `${s.slice(0, len - 1)}…` : s;
+}
+
+function pad(s: string, len: number): string {
+  return s.padEnd(len);
+}
+
+export const listCommand = new Command("list")
+  .description("List articles")
+  .option("--status <status>", "Filter by status")
+  .option("--site <siteId>", "Filter by site ID")
+  .option("--limit <n>", "Max results", "20")
+  .action(async (opts) => {
+    try {
+      const params = new URLSearchParams();
+      if (opts.status) params.set("status", opts.status);
+      if (opts.site) params.set("siteId", opts.site);
+      params.set("limit", opts.limit);
+
+      const qs = params.toString();
+      const data = await apiGet<{ data: Article[]; count: number }>(
+        `/v1/articles${qs ? `?${qs}` : ""}`,
+      );
+
+      const articles: Article[] = data.data ?? [];
+
+      if (articles.length === 0) {
+        console.log("No articles found.");
+        return;
+      }
+
+      // header
+      console.log(
+        `${pad("ID", 38)}${pad("Title/Topic", 40)}${pad("Status", 14)}${pad("Words", 8)}Created`,
+      );
+      console.log("-".repeat(110));
+
+      for (const a of articles) {
+        const label = a.title ?? a.topic;
+        console.log(
+          `${pad(a.id, 38)}${pad(truncate(label, 38), 40)}${pad(a.status, 14)}${pad(String(a.wordCount), 8)}${a.createdAt}`,
+        );
+      }
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/status.ts

@@ -0,0 +1,24 @@
+import { Command } from "commander";
+import { apiGet } from "../client.js";
+import type { Article } from "@contentkong/shared";
+
+export const statusCommand = new Command("status")
+  .description("Check article generation status")
+  .argument("<articleId>", "Article ID")
+  .action(async (articleId: string) => {
+    try {
+      const a = await apiGet<Article>(`/v1/articles/${articleId}`);
+      console.log(`ID:        ${a.id}`);
+      console.log(`Status:    ${a.status}`);
+      console.log(`Topic:     ${a.topic}`);
+      if (a.title) console.log(`Title:     ${a.title}`);
+      console.log(`Words:     ${a.wordCount}`);
+      console.log(`Type:      ${a.articleType}`);
+      console.log(`Length:    ${a.articleLength}`);
+      console.log(`Created:   ${a.createdAt}`);
+      if (a.completedAt) console.log(`Completed: ${a.completedAt}`);
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/voices.ts

@@ -0,0 +1,55 @@
+import { Command } from "commander";
+import { apiGet } from "../client.js";
+import type { Voice } from "@contentkong/shared";
+
+function pad(s: string, len: number): string {
+  return s.padEnd(len);
+}
+
+const voicesList = new Command("list")
+  .description("List all voices")
+  .action(async () => {
+    try {
+      const data = await apiGet<{ data: Voice[]; count: number }>("/v1/voices");
+      const voices: Voice[] = data.data ?? [];
+
+      if (voices.length === 0) {
+        console.log("No voices found.");
+        return;
+      }
+
+      console.log(`${pad("ID", 38)}${pad("Name", 30)}Preset`);
+      console.log("-".repeat(80));
+
+      for (const v of voices) {
+        console.log(
+          `${pad(v.id, 38)}${pad(v.name, 30)}${v.preset ?? "-"}`,
+        );
+      }
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  });
+
+const voicesGet = new Command("get")
+  .description("Get voice details")
+  .argument("<id>", "Voice ID")
+  .action(async (id: string) => {
+    try {
+      const v = await apiGet<Voice>(`/v1/voices/${id}`);
+      console.log(`ID:          ${v.id}`);
+      console.log(`Name:        ${v.name}`);
+      if (v.preset) console.log(`Preset:      ${v.preset}`);
+      if (v.customDescription)
+        console.log(`Description: ${v.customDescription}`);
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  });
+
+export const voicesCommand = new Command("voices")
+  .description("Manage voices")
+  .addCommand(voicesList)
+  .addCommand(voicesGet);

package/src/index.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { configureClient } from "./client.js";
+import { generateCommand } from "./commands/generate.js";
+import { statusCommand } from "./commands/status.js";
+import { getCommand } from "./commands/get.js";
+import { listCommand } from "./commands/list.js";
+import { exportCommand } from "./commands/export.js";
+import { voicesCommand } from "./commands/voices.js";
+
+const program = new Command();
+
+program
+  .name("ckx")
+  .description("ContentKong CLI")
+  .version("0.1.0")
+  .option("--api-key <key>", "API key (or set CK_API_KEY)")
+  .option("--api-url <url>", "API base URL (or set CK_API_URL)")
+  .hook("preAction", (_thisCommand) => {
+    const opts = program.opts<{ apiKey?: string; apiUrl?: string }>();
+    configureClient({ apiKey: opts.apiKey, apiUrl: opts.apiUrl });
+  });
+
+program.addCommand(generateCommand);
+program.addCommand(statusCommand);
+program.addCommand(getCommand);
+program.addCommand(listCommand);
+program.addCommand(exportCommand);
+program.addCommand(voicesCommand);
+
+program.parse();

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}