@stackbilt/aegis-core 0.1.0

package/src/content/column.ts

@@ -0,0 +1,80 @@
+// Stub — full implementation not yet extracted to OSS
+
+import { sanitizeForBlog } from '../sanitize.js';
+
+export interface ColumnOutput {
+  title: string;
+  slug: string;
+  meta_description: string;
+  body: string;
+}
+
+export async function generateColumn(
+  apiKey: string,
+  model: string,
+  baseUrl: string,
+  activityContext: string,
+): Promise<{ output: ColumnOutput; cost: number }> {
+  const response = await fetch(baseUrl, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'Content-Type': 'application/json',
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 2048,
+      messages: [{ role: 'user', content: `Write an AEGIS column based on recent activity:\n\n${activityContext}` }],
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${text}`);
+  }
+
+  const data = await response.json() as {
+    content: Array<{ type: string; text: string }>;
+    usage: { input_tokens: number; output_tokens: number };
+  };
+
+  let text = data.content[0].text;
+  text = text.replace(/^```json\n?/, '').replace(/\n?```$/, '');
+
+  const parsed = JSON.parse(text);
+  const output: ColumnOutput = {
+    title: parsed.title ?? '',
+    slug: parsed.slug ?? '',
+    meta_description: parsed.meta_description ?? '',
+    body: sanitizeForBlog(parsed.body ?? ''),
+  };
+
+  if (!output.title || !output.slug || !output.body) {
+    throw new Error('Invalid column output structure');
+  }
+
+  const cost = (data.usage.input_tokens * 3 + data.usage.output_tokens * 15) / 1_000_000;
+
+  return { output, cost };
+}
+
+export async function writeColumn(
+  db: D1Database,
+  output: ColumnOutput,
+): Promise<string> {
+  const id = crypto.randomUUID();
+
+  await db.prepare(
+    `INSERT INTO roundtables (id, topic, slug, meta_description, header_image_url, cta_url, status, quick_specs, synthesis)
+     VALUES (?, 'aegis_column', ?, ?, NULL, ?, 'draft', '[]', ?)`,
+  ).bind(
+    id,
+    output.slug,
+    output.meta_description,
+    'https://example.com',
+    output.body,
+  ).run();
+
+  return id;
+}

package/src/content/hero-image.ts

@@ -0,0 +1,47 @@
+// Stub — full implementation not yet extracted to OSS
+
+export interface ImgForgeConfig {
+  fetcher: Fetcher;
+  sbSecret: string;
+  baseUrl: string;
+}
+
+type QualityTier = 'standard' | 'ultra' | 'ultra_plus';
+
+const TEXT_CAPABLE_TIERS: QualityTier[] = ['ultra', 'ultra_plus'];
+
+const NO_TEXT_SUFFIX = '\n\nDo not include any text, letters, words, or typography in the image.';
+
+export async function generateHeroImage(
+  config: ImgForgeConfig,
+  prompt: string,
+  tier: QualityTier = 'standard',
+): Promise<string | null> {
+  try {
+    const finalPrompt = TEXT_CAPABLE_TIERS.includes(tier)
+      ? prompt
+      : prompt + NO_TEXT_SUFFIX;
+
+    const response = await config.fetcher.fetch('https://internal/v2/generate', {
+      method: 'POST',
+      headers: {
+        'X-Service-Binding': config.sbSecret,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        prompt: finalPrompt,
+        quality_tier: tier,
+        sync: true,
+      }),
+    });
+
+    if (!response.ok) return null;
+
+    const data = await response.json() as { asset_url: string | null };
+    if (!data.asset_url) return null;
+
+    return `${config.baseUrl}${data.asset_url}`;
+  } catch {
+    return null;
+  }
+}

package/src/content/index.ts

@@ -0,0 +1,27 @@
+// Stub — full implementation not yet extracted to OSS
+
+export { type ImgForgeConfig } from './hero-image.js';
+
+export async function runRoundtableGeneration(
+  _roundtableDb: D1Database,
+  _aegisDb: D1Database,
+  _apiKey: string,
+  _model: string,
+  _baseUrl: string,
+): Promise<{ title: string; slug: string; cost: number }> {
+  throw new Error('not implemented');
+}
+
+export async function queueRoundtableTopic(
+  _roundtableDb: D1Database,
+  _topic: string,
+  _context: string,
+  _ctaProduct: string,
+  _source: string,
+): Promise<number> {
+  throw new Error('not implemented');
+}
+
+export async function runJournalGeneration(env: any): Promise<{ ok: boolean }> {
+  throw new Error('not implemented');
+}

package/src/content/journal.ts

@@ -0,0 +1,91 @@
+// Stub — full implementation not yet extracted to OSS
+
+import { sanitizeForBlog } from '../sanitize.js';
+
+export interface JournalOutput {
+  title: string;
+  slug: string;
+  meta_description: string;
+  body: string;
+  mood: string;
+  tags: string[];
+}
+
+export async function generateJournal(
+  apiKey: string,
+  model: string,
+  baseUrl: string,
+  activityContext: string,
+): Promise<{ output: JournalOutput; cost: number }> {
+  const response = await fetch(baseUrl, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'Content-Type': 'application/json',
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 1536,
+      messages: [{ role: 'user', content: `Write an AEGIS journal entry based on recent activity:\n\n${activityContext}` }],
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${text}`);
+  }
+
+  const data = await response.json() as {
+    content: Array<{ type: string; text: string }>;
+    usage: { input_tokens: number; output_tokens: number };
+  };
+
+  let text = data.content[0].text;
+  text = text.replace(/^```json\n?/, '').replace(/\n?```$/, '');
+
+  const parsed = JSON.parse(text);
+  const output: JournalOutput = {
+    title: parsed.title ?? '',
+    slug: parsed.slug ?? '',
+    meta_description: parsed.meta_description ?? '',
+    body: sanitizeForBlog(parsed.body ?? ''),
+    mood: parsed.mood ?? 'focused',
+    tags: Array.isArray(parsed.tags) ? parsed.tags : [],
+  };
+
+  if (!output.title || !output.slug || !output.body) {
+    throw new Error('Invalid journal output structure');
+  }
+
+  const cost = (data.usage.input_tokens * 3 + data.usage.output_tokens * 15) / 1_000_000;
+
+  return { output, cost };
+}
+
+export async function writeJournal(
+  db: D1Database,
+  output: JournalOutput,
+  headerImageUrl: string | null = null,
+): Promise<string> {
+  const id = crypto.randomUUID();
+
+  const quickSpecs = JSON.stringify([
+    { label: 'Mood', value: output.mood },
+    ...output.tags.map(tag => ({ label: 'Tag', value: tag })),
+  ]);
+
+  await db.prepare(
+    `INSERT INTO roundtables (id, topic, slug, meta_description, header_image_url, cta_url, status, quick_specs, synthesis)
+     VALUES (?, 'aegis_journal', ?, ?, ?, 'https://example.com', 'published', ?, ?)`,
+  ).bind(
+    id,
+    output.slug,
+    output.meta_description,
+    headerImageUrl,
+    quickSpecs,
+    output.body,
+  ).run();
+
+  return id;
+}

package/src/content/roundtable.ts

@@ -0,0 +1,163 @@
+// Stub — full implementation not yet extracted to OSS
+
+import { sanitizeForBlog } from '../sanitize.js';
+
+export interface RoundtableOutput {
+  title: string;
+  slug: string;
+  meta_description: string;
+  executive_summary: Array<{ metric: string; status: string; takeaway: string }>;
+  quick_specs: Array<{ label: string; value: string }>;
+  contributions: Array<{ persona: string; content: string; key_findings: string[] }>;
+  synthesis: string;
+}
+
+const CTA_URLS: Record<string, string> = {
+  'demo-app': 'https://demo-app.example.com',
+  'img-forge': 'https://img-forge.example.com',
+};
+
+// ─── pickNextTopic ──────────────────────────────────────────
+
+export async function pickNextTopic(
+  db: D1Database,
+): Promise<{ id: string; topic: string; context: string; cta_product: string } | null> {
+  const topic = await db.prepare(
+    "SELECT id, topic, context, cta_product FROM topic_queue WHERE status = 'queued' ORDER BY created_at ASC LIMIT 1"
+  ).first<{ id: string; topic: string; context: string; cta_product: string }>();
+
+  if (!topic) return null;
+
+  await db.prepare(
+    "UPDATE topic_queue SET status = 'used' WHERE id = ?"
+  ).bind(topic.id).run();
+
+  return topic;
+}
+
+// ─── generateRoundtable ─────────────────────────────────────
+
+export async function generateRoundtable(
+  apiKey: string,
+  model: string,
+  baseUrl: string,
+  topic: string,
+  context: string | null,
+  ctaProduct: string | null,
+): Promise<{ output: RoundtableOutput; cost: number }> {
+  let userMessage = `Generate a roundtable discussion about: ${topic}`;
+  if (context) userMessage += `\n\nCONTEXT: ${context}`;
+  if (ctaProduct) userMessage += `\nCTA_PRODUCT: ${ctaProduct}`;
+
+  const response = await fetch(baseUrl, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'Content-Type': 'application/json',
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      messages: [{ role: 'user', content: userMessage }],
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${text}`);
+  }
+
+  const data = await response.json() as {
+    content: Array<{ type: string; text: string }>;
+    usage: { input_tokens: number; output_tokens: number };
+  };
+
+  let text = data.content[0].text;
+  text = text.replace(/^```json\n?/, '').replace(/\n?```$/, '');
+
+  const parsed = JSON.parse(text);
+  const output: RoundtableOutput = {
+    title: parsed.title ?? '',
+    slug: parsed.slug ?? '',
+    meta_description: parsed.meta_description ?? '',
+    executive_summary: Array.isArray(parsed.executive_summary) ? parsed.executive_summary : [],
+    quick_specs: Array.isArray(parsed.quick_specs) ? parsed.quick_specs : [],
+    contributions: (Array.isArray(parsed.contributions) ? parsed.contributions : []).map(
+      (c: any) => ({
+        persona: c.persona ?? '',
+        content: sanitizeForBlog(c.content ?? ''),
+        key_findings: Array.isArray(c.key_findings) ? c.key_findings : [],
+      }),
+    ),
+    synthesis: parsed.synthesis ?? '',
+  };
+
+  if (!output.title || output.contributions.length === 0) {
+    throw new Error('Invalid roundtable output structure');
+  }
+
+  const cost = (data.usage.input_tokens * 3 + data.usage.output_tokens * 15) / 1_000_000;
+
+  return { output, cost };
+}
+
+// ─── writeRoundtable ────────────────────────────────────────
+
+export async function writeRoundtable(
+  db: D1Database,
+  output: RoundtableOutput,
+  ctaProduct: string | null,
+  headerImageUrl: string | null = null,
+): Promise<string> {
+  const id = crypto.randomUUID();
+  const ctaUrl = (ctaProduct && CTA_URLS[ctaProduct]) ?? 'https://example.com';
+
+  await db.prepare(
+    `INSERT INTO roundtables (id, topic, slug, meta_description, header_image_url, cta_url, status, executive_summary, quick_specs, synthesis)
+     VALUES (?, ?, ?, ?, ?, ?, 'draft', ?, ?, ?)`,
+  ).bind(
+    id,
+    output.title,
+    output.slug,
+    output.meta_description,
+    headerImageUrl,
+    ctaUrl,
+    JSON.stringify(output.executive_summary),
+    JSON.stringify(output.quick_specs),
+    output.synthesis,
+  ).run();
+
+  for (const contribution of output.contributions) {
+    await db.prepare(
+      'INSERT INTO contributions (roundtable_id, persona, content, key_findings) VALUES (?, ?, ?, ?)'
+    ).bind(id, contribution.persona, contribution.content, JSON.stringify(contribution.key_findings)).run();
+  }
+
+  return id;
+}
+
+// ─── queueRoundtableTopic ───────────────────────────────────
+
+export async function queueRoundtableTopic(
+  db: D1Database,
+  topic: string,
+  context: string | null,
+  ctaProduct: string | null,
+  source: string,
+): Promise<string> {
+  // Check for duplicate
+  const existing = await db.prepare(
+    "SELECT id FROM topic_queue WHERE topic = ? AND status = 'queued'"
+  ).bind(topic).first<{ id: string }>();
+
+  if (existing) return existing.id;
+
+  const id = crypto.randomUUID();
+
+  await db.prepare(
+    'INSERT INTO topic_queue (id, topic, context, cta_product, source, status) VALUES (?, ?, ?, ?, ?, ?)'
+  ).bind(id, topic, context, ctaProduct ?? 'general', source, 'queued').run();
+
+  return id;
+}