@sourcepress/ai 0.1.0

package/src/functions/find-gaps.ts

@@ -0,0 +1,65 @@
+import { generateObject } from "ai";
+import { z } from "zod";
+import type { BudgetTracker } from "../budget.js";
+import type { ResolvedProvider } from "../provider.js";
+import type { FindGapsInput, FindGapsResult } from "../types.js";
+import { createModel } from "./model-factory.js";
+import { recordUsage } from "./usage.js";
+
+const findGapsSchema = z.object({
+	gaps: z.array(
+		z.object({
+			entity_name: z.string(),
+			entity_type: z.string(),
+			suggested_content_type: z.string(),
+			priority: z.enum(["high", "medium", "low"]),
+			reason: z.string(),
+		}),
+	),
+});
+
+export async function findGaps(
+	input: FindGapsInput,
+	provider: ResolvedProvider,
+	budget: BudgetTracker,
+): Promise<FindGapsResult> {
+	const entityList = input.entities.map((e) => `- ${e.name} (${e.type})`).join("\n");
+	const relationList =
+		input.relations.length > 0
+			? input.relations.map((r) => `- ${r.from} --[${r.type}]--> ${r.to}`).join("\n")
+			: "No relations yet.";
+	const contentList =
+		input.existing_content.length > 0
+			? input.existing_content.map((c) => `- ${c.path}: "${c.title}" — ${c.summary}`).join("\n")
+			: "No content yet.";
+	const businessContext = input.business_context
+		? `\nBusiness context:\n${input.business_context}\n`
+		: "";
+
+	const { object, usage } = await generateObject({
+		model: await createModel(provider),
+		schema: findGapsSchema,
+		prompt: `You are a content gap analyzer for a content engine. Identify entities from the knowledge graph that should have dedicated content pages but currently don't.
+
+Knowledge graph entities:
+${entityList}
+
+Relations:
+${relationList}
+
+Existing content:
+${contentList}
+${businessContext}
+
+For each gap, determine:
+- Which entity lacks content
+- What type of content would best serve it (blog-post, case-study, service-page, landing-page, documentation)
+- Priority: "high" (core business entity, many relations), "medium" (useful but not critical), "low" (nice to have)
+- Why this gap matters
+
+Only report genuine gaps.`,
+	});
+
+	const tokenUsage = recordUsage(budget, provider, usage, "findGaps");
+	return { gaps: object.gaps, usage: tokenUsage };
+}

package/src/functions/generate.ts

@@ -0,0 +1,51 @@
+import { generateObject } from "ai";
+import { z } from "zod";
+import type { BudgetTracker } from "../budget.js";
+import type { ResolvedProvider } from "../provider.js";
+import type { GenerateInput, GenerateResult } from "../types.js";
+import { createModel } from "./model-factory.js";
+import { recordUsage } from "./usage.js";
+
+const generateSchema = z.object({
+	frontmatter: z.record(z.unknown()),
+	body: z.string(),
+});
+
+export async function generate(
+	input: GenerateInput,
+	provider: ResolvedProvider,
+	budget: BudgetTracker,
+): Promise<GenerateResult> {
+	const intentSection = input.intent
+		? `\nIntent/tone-of-voice rules:\n---\n${input.intent}\n---\n`
+		: "";
+
+	const schemaSection = input.collection_schema
+		? `\nExpected frontmatter fields:\n${JSON.stringify(input.collection_schema, null, 2)}\n`
+		: "";
+
+	const { object, usage } = await generateObject({
+		model: await createModel(provider),
+		schema: generateSchema,
+		prompt: `${input.generation_prompt}
+
+You are generating content of type "${input.content_type}" for a content engine. Use ONLY the knowledge context provided below. Do not invent facts.
+
+Knowledge context:
+---
+${input.knowledge_context}
+---
+${intentSection}${schemaSection}
+Return a JSON object with:
+- "frontmatter": an object with metadata fields (title, description, etc.)
+- "body": the full content body in markdown format`,
+	});
+
+	const tokenUsage = recordUsage(budget, provider, usage, "generate");
+
+	return {
+		content: object.body,
+		frontmatter: object.frontmatter,
+		usage: tokenUsage,
+	};
+}

package/src/functions/improve-prompt.ts

@@ -0,0 +1,48 @@
+import { generateObject } from "ai";
+import { z } from "zod";
+import type { BudgetTracker } from "../budget.js";
+import type { ResolvedProvider } from "../provider.js";
+import type { ImprovePromptInput, ImprovePromptResult } from "../types.js";
+import { createModel } from "./model-factory.js";
+import { recordUsage } from "./usage.js";
+
+const improvePromptSchema = z.object({
+	improved_prompt: z.string(),
+	changes_summary: z.string(),
+});
+
+export async function improvePrompt(
+	input: ImprovePromptInput,
+	provider: ResolvedProvider,
+	budget: BudgetTracker,
+): Promise<ImprovePromptResult> {
+	const { object, usage } = await generateObject({
+		model: await createModel(provider),
+		schema: improvePromptSchema,
+		prompt: `You are a prompt engineer improving a content generation prompt. The current prompt was used to generate "${input.content_type}" content, but the judge gave it a score of ${input.judge_score}/100.
+
+Current generation prompt:
+---
+${input.current_prompt}
+---
+
+Judge's reasoning for the low score:
+---
+${input.judge_reasoning}
+---
+
+Improve the generation prompt to address the judge's feedback. Keep the same overall structure but make it more specific about what the judge found lacking. Do NOT change the fundamental approach — just refine the instructions.
+
+Return:
+- "improved_prompt": the full improved prompt text
+- "changes_summary": a brief summary of what you changed and why`,
+	});
+
+	const tokenUsage = recordUsage(budget, provider, usage, "improvePrompt");
+
+	return {
+		improved_prompt: object.improved_prompt,
+		changes_summary: object.changes_summary,
+		usage: tokenUsage,
+	};
+}

package/src/functions/index.ts

@@ -0,0 +1,10 @@
+export { classify } from "./classify.js";
+export { extract } from "./extract.js";
+export { score } from "./score.js";
+export { judge } from "./judge.js";
+export { detectStaleness } from "./staleness.js";
+export { analyzeIntentImpact } from "./intent-impact.js";
+export { findGaps } from "./find-gaps.js";
+export { generate } from "./generate.js";
+export { improvePrompt } from "./improve-prompt.js";
+export { recordUsage } from "./usage.js";

package/src/functions/intent-impact.ts

@@ -0,0 +1,56 @@
+import { generateObject } from "ai";
+import { z } from "zod";
+import type { BudgetTracker } from "../budget.js";
+import type { ResolvedProvider } from "../provider.js";
+import type { IntentImpactInput, IntentImpactResult } from "../types.js";
+import { createModel } from "./model-factory.js";
+import { recordUsage } from "./usage.js";
+
+const intentImpactSchema = z.object({
+	affected_pages: z.array(
+		z.object({ path: z.string(), impact: z.enum(["high", "medium", "low"]), reason: z.string() }),
+	),
+	summary: z.string(),
+});
+
+export async function analyzeIntentImpact(
+	input: IntentImpactInput,
+	provider: ResolvedProvider,
+	budget: BudgetTracker,
+): Promise<IntentImpactResult> {
+	const contentList = input.content_pages
+		.map((p) => `Page: ${p.path}\n---\n${p.text}\n---`)
+		.join("\n\n");
+	const { object, usage } = await generateObject({
+		model: await createModel(provider),
+		schema: intentImpactSchema,
+		prompt: `You are an intent impact analyzer for a content engine. When editorial intent rules change, you identify which published content pages are affected.
+
+Previous intent rules:
+---
+${input.previous_intent}
+---
+
+New intent rules:
+---
+${input.changed_intent}
+---
+
+Analyze each content page and determine if it violates the NEW rules (but was fine under the old rules).
+
+Impact levels:
+- "high": Directly violates new rules (e.g., uses a now-forbidden word, wrong tone)
+- "medium": Partially misaligned, needs revision
+- "low": Minor adjustment needed
+
+Only include pages that are actually affected.
+
+Content pages:
+${contentList}
+
+Return the list of affected pages with impact level and reason, plus a brief summary.`,
+	});
+
+	const tokenUsage = recordUsage(budget, provider, usage, "analyzeIntentImpact");
+	return { affected_pages: object.affected_pages, summary: object.summary, usage: tokenUsage };
+}

package/src/functions/judge.ts

@@ -0,0 +1,41 @@
+import { generateObject } from "ai";
+import { z } from "zod";
+import type { BudgetTracker } from "../budget.js";
+import type { ResolvedProvider } from "../provider.js";
+import type { JudgeInput, JudgeResult } from "../types.js";
+import { createModel } from "./model-factory.js";
+import { recordUsage } from "./usage.js";
+
+const judgeSchema = z.object({ score: z.number().min(0).max(100), reasoning: z.string() });
+
+export async function judge(
+	input: JudgeInput,
+	provider: ResolvedProvider,
+	budget: BudgetTracker,
+): Promise<JudgeResult> {
+	const intentSection = input.intent
+		? `\nIntent/tone-of-voice rules:\n---\n${input.intent}\n---\n`
+		: "";
+	const { object, usage } = await generateObject({
+		model: await createModel(provider),
+		schema: judgeSchema,
+		prompt: `${input.judge_prompt}
+
+You are evaluating a content draft against a gold standard example. Compare quality, structure, specificity, tone, and accuracy.
+
+Gold standard (this is what "perfect" looks like):
+---
+${input.gold_standard}
+---
+${intentSection}
+Draft to evaluate:
+---
+${input.draft}
+---
+
+Return a single score (0-100) and detailed reasoning explaining the score.`,
+	});
+
+	const tokenUsage = recordUsage(budget, provider, usage, "judge");
+	return { score: object.score, reasoning: object.reasoning, usage: tokenUsage };
+}

package/src/functions/model-factory.ts

@@ -0,0 +1,60 @@
+import type { LanguageModel } from "ai";
+import type { ResolvedProvider } from "../provider.js";
+
+export async function createModel(provider: ResolvedProvider): Promise<LanguageModel> {
+	switch (provider.provider) {
+		case "anthropic":
+			return createAnthropicModel(provider);
+		case "openai":
+			return createOpenAIModel(provider);
+		case "local":
+			return createLocalModel(provider);
+		default:
+			throw new Error(`Unknown provider: ${provider.provider}`);
+	}
+}
+
+async function createAnthropicModel(provider: ResolvedProvider): Promise<LanguageModel> {
+	try {
+		const { createAnthropic } = await import("@ai-sdk/anthropic");
+		const anthropic = createAnthropic({
+			apiKey: provider.apiKey,
+			...(provider.baseUrl && { baseURL: provider.baseUrl }),
+		});
+		return anthropic(provider.model) as unknown as LanguageModel;
+	} catch {
+		throw new Error(
+			'Provider "anthropic" requires @ai-sdk/anthropic. Install it with: pnpm add @ai-sdk/anthropic',
+		);
+	}
+}
+
+async function createOpenAIModel(provider: ResolvedProvider): Promise<LanguageModel> {
+	try {
+		const { createOpenAI } = await import("@ai-sdk/openai");
+		const openai = createOpenAI({
+			apiKey: provider.apiKey,
+			...(provider.baseUrl && { baseURL: provider.baseUrl }),
+		});
+		return openai(provider.model) as unknown as LanguageModel;
+	} catch {
+		throw new Error(
+			'Provider "openai" requires @ai-sdk/openai. Install it with: pnpm add @ai-sdk/openai',
+		);
+	}
+}
+
+async function createLocalModel(provider: ResolvedProvider): Promise<LanguageModel> {
+	try {
+		const { createOpenAI } = await import("@ai-sdk/openai");
+		const local = createOpenAI({
+			baseURL: provider.baseUrl ?? "http://localhost:11434/v1",
+			apiKey: "local",
+		});
+		return local(provider.model) as unknown as LanguageModel;
+	} catch {
+		throw new Error(
+			'Provider "local" requires @ai-sdk/openai (used as compatible client). Install it with: pnpm add @ai-sdk/openai',
+		);
+	}
+}

package/src/functions/score.ts

@@ -0,0 +1,56 @@
+import { generateObject } from "ai";
+import { z } from "zod";
+import type { BudgetTracker } from "../budget.js";
+import type { ResolvedProvider } from "../provider.js";
+import type { ScoreInput, ScoreResult } from "../types.js";
+import { createModel } from "./model-factory.js";
+import { recordUsage } from "./usage.js";
+
+const scoreSchema = z.object({
+	score: z.number().min(0).max(100),
+	issues: z.array(z.string()),
+	strengths: z.array(z.string()),
+});
+
+export async function score(
+	input: ScoreInput,
+	provider: ResolvedProvider,
+	budget: BudgetTracker,
+): Promise<ScoreResult> {
+	const collectionContext = input.collection_name
+		? `This content belongs to the "${input.collection_name}" collection.`
+		: "";
+	const { object, usage } = await generateObject({
+		model: await createModel(provider),
+		schema: scoreSchema,
+		prompt: `You are a content quality evaluator for a content engine. Score the following content against the provided intent rules.
+
+Score 0-100 where:
+- 90-100: Excellent — fully matches intent, no issues
+- 70-89: Good — mostly matches, minor issues
+- 50-69: Fair — partially matches, notable issues
+- 0-49: Poor — significant mismatches with intent
+
+${collectionContext}
+
+Intent rules:
+---
+${input.intent}
+---
+
+Content to evaluate:
+---
+${input.content}
+---
+
+Provide a score, list of issues (things that don't match intent), and strengths (things that match well).`,
+	});
+
+	const tokenUsage = recordUsage(budget, provider, usage, "score");
+	return {
+		score: object.score,
+		issues: object.issues,
+		strengths: object.strengths,
+		usage: tokenUsage,
+	};
+}

package/src/functions/staleness.ts

@@ -0,0 +1,54 @@
+import { generateObject } from "ai";
+import { z } from "zod";
+import type { BudgetTracker } from "../budget.js";
+import type { ResolvedProvider } from "../provider.js";
+import type { StalenessInput, StalenessResult } from "../types.js";
+import { createModel } from "./model-factory.js";
+import { recordUsage } from "./usage.js";
+
+const stalenessSchema = z.object({
+	stale: z.boolean(),
+	reason: z.string(),
+	stale_sources: z.array(z.string()),
+	confidence: z.number().min(0).max(1),
+});
+
+export async function detectStaleness(
+	input: StalenessInput,
+	provider: ResolvedProvider,
+	budget: BudgetTracker,
+): Promise<StalenessResult> {
+	const sourceSections = input.source_texts
+		.map((s) => `Source: ${s.path} (updated: ${s.updated_at})\n---\n${s.text}\n---`)
+		.join("\n\n");
+	const { object, usage } = await generateObject({
+		model: await createModel(provider),
+		schema: stalenessSchema,
+		prompt: `You are a content freshness analyzer. Determine if the published content is stale compared to its source knowledge files.
+
+Content is stale if the source files contain NEW INFORMATION that is not reflected in the content. Minor formatting changes or rewording in sources do NOT make content stale.
+
+Published content (generated at ${input.content_generated_at}):
+---
+${input.content}
+---
+
+Source knowledge files:
+${sourceSections}
+
+Determine:
+1. Is the content stale? (true/false)
+2. Why or why not?
+3. Which specific source files made it stale? (list their paths)
+4. How confident are you? (0.0-1.0)`,
+	});
+
+	const tokenUsage = recordUsage(budget, provider, usage, "detectStaleness");
+	return {
+		stale: object.stale,
+		reason: object.reason,
+		stale_sources: object.stale_sources,
+		confidence: object.confidence,
+		usage: tokenUsage,
+	};
+}

package/src/functions/usage.ts

@@ -0,0 +1,25 @@
+import type { BudgetTracker } from "../budget.js";
+import type { ResolvedProvider } from "../provider.js";
+import { estimateCost } from "../provider.js";
+import type { TokenUsage } from "../types.js";
+
+export function recordUsage(
+	budget: BudgetTracker,
+	provider: ResolvedProvider,
+	usage: { promptTokens?: number; completionTokens?: number } | undefined,
+	functionName: string,
+): TokenUsage {
+	const tokenUsage: TokenUsage = {
+		input_tokens: usage?.promptTokens ?? 0,
+		output_tokens: usage?.completionTokens ?? 0,
+		estimated_cost_usd: estimateCost(
+			provider.model,
+			usage?.promptTokens ?? 0,
+			usage?.completionTokens ?? 0,
+		),
+		function_name: functionName,
+		timestamp: new Date().toISOString(),
+	};
+	budget.record(tokenUsage);
+	return tokenUsage;
+}

package/src/index.ts

@@ -0,0 +1,47 @@
+export { BudgetTracker } from "./budget.js";
+export { resolveProvider, estimateCost } from "./provider.js";
+export type { ResolvedProvider } from "./provider.js";
+export {
+	classify,
+	extract,
+	score,
+	judge,
+	detectStaleness,
+	analyzeIntentImpact,
+	findGaps,
+	generate,
+	improvePrompt,
+	recordUsage,
+} from "./functions/index.js";
+export { createModel } from "./functions/model-factory.js";
+export { EvalRunner } from "./eval/runner.js";
+export type {
+	AIProviderConfig,
+	BudgetConfig,
+	BudgetStatus,
+	TokenUsage,
+	ClassifyInput,
+	ClassifyResult,
+	ExtractInput,
+	ExtractResult,
+	ExtractedEntityResult,
+	ExtractedRelationResult,
+	ScoreInput,
+	ScoreResult,
+	JudgeInput,
+	JudgeResult,
+	StalenessInput,
+	StalenessResult,
+	IntentImpactInput,
+	IntentImpactResult,
+	FindGapsInput,
+	FindGapsResult,
+	IntelligenceProvider,
+	GenerateInput,
+	GenerateResult,
+	ImprovePromptInput,
+	ImprovePromptResult,
+	EvalResult,
+	EvalRunConfig,
+	EvalRunResult,
+} from "./types.js";

package/src/provider.ts

@@ -0,0 +1,41 @@
+import type { AIProviderConfig } from "./types.js";
+
+export interface ResolvedProvider {
+	provider: AIProviderConfig["provider"];
+	model: string;
+	apiKey?: string;
+	baseUrl?: string;
+}
+
+export function resolveProvider(config: AIProviderConfig): ResolvedProvider {
+	return {
+		provider: config.provider,
+		model: config.model,
+		apiKey: config.apiKey,
+		baseUrl: config.baseUrl,
+	};
+}
+
+const COST_TABLE: Record<string, { input: number; output: number }> = {
+	"claude-sonnet-4-6": { input: 3.0, output: 15.0 },
+	"claude-sonnet-4-5": { input: 3.0, output: 15.0 },
+	"claude-haiku-4-5": { input: 0.25, output: 1.25 },
+	"claude-opus-4-6": { input: 15.0, output: 75.0 },
+	"gpt-4o": { input: 2.5, output: 10.0 },
+	"gpt-4o-mini": { input: 0.15, output: 0.6 },
+	local: { input: 0, output: 0 },
+};
+
+export function estimateCost(model: string, inputTokens: number, outputTokens: number): number {
+	let costs = COST_TABLE[model];
+	if (!costs) {
+		for (const [key, value] of Object.entries(COST_TABLE)) {
+			if (model.startsWith(key)) {
+				costs = value;
+				break;
+			}
+		}
+	}
+	if (!costs) costs = { input: 3.0, output: 15.0 };
+	return (inputTokens / 1_000_000) * costs.input + (outputTokens / 1_000_000) * costs.output;
+}