2sagaco48 1.0.0

package/src/lib/sage/index.ts

@@ -0,0 +1,17 @@
+/**
+ * SAGE public barrel — Story Archetype Generation Engine.
+ */
+export * from "./taxonomy";
+export * from "./prng";
+export * from "./engine";
+export * from "./empty-space";
+export * from "./repetition";
+export * from "./judge";
+export * from "./worked-sketches";
+export * from "./saga-os";
+export * from "./saga-os-v2";
+export * from "./saga-os-v4";
+export * from "./saga-os-v5";
+export * from "./saga-os-v6";
+export * from "./saga-os-v7";
+export * from "./saga-os-v8";

package/src/lib/sage/judge.ts

@@ -0,0 +1,246 @@
+/**
+ * SAGE Manuscript Judge — publisher-style editorial grading.
+ * ---------------------------------------------------------------------------
+ * Two independent evidence lanes, combined honestly (never self-declared as
+ * "verified" from LLM output alone):
+ *
+ *  1. COMPUTED metrics — real, deterministic, local JS execution. No LLM call.
+ *     Flesch Reading Ease (syllable-heuristic), sentence/paragraph length and
+ *     variance, dialogue ratio, type-token (distinct-word) ratio as a
+ *     repetition proxy, repeated-phrase density.
+ *  2. LLM RUBRIC — one model call asking for structured scores across the
+ *     categories a human developmental editor / acquisitions reader would
+ *     use, plus fractal rewrite targets (chapter -> scene -> sentence).
+ *
+ * The LLM lane is clearly labeled as a model judgment, not a verified fact.
+ * If JSON parsing fails, the raw text is preserved and `parseError` is set
+ * rather than fabricating a score.
+ */
+import type { SageBlueprint } from "./engine";
+
+export type ProseMetrics = {
+  wordCount: number;
+  sentenceCount: number;
+  paragraphCount: number;
+  avgSentenceLenWords: number;
+  sentenceLenStdev: number;
+  avgParagraphLenSentences: number;
+  paragraphLenStdev: number;
+  dialogueRatio: number;
+  distinctWordRatio: number;
+  fleschReadingEase: number;
+  fleschLabel: string;
+  repeatedPhraseDensity: number;
+};
+
+export type RewriteTarget = {
+  scope: "chapter" | "scene" | "paragraph" | "sentence";
+  location: string;
+  issue: string;
+  suggestion: string;
+};
+
+export type JudgeRubricScores = {
+  plotStructure: number;
+  characterization: number;
+  proseStyle: number;
+  dialogue: number;
+  pacing: number;
+  emotionalResonance: number;
+  thematicDepth: number;
+  realWorldRelation: number;
+  originality: number;
+  readabilityJudgment: number;
+  marketability: number;
+  overall: number;
+};
+
+export type ManuscriptGradeReport = {
+  metrics: ProseMetrics;
+  rubric: JudgeRubricScores | null;
+  justifications: Partial<Record<keyof JudgeRubricScores, string>> | null;
+  rewriteTargets: RewriteTarget[];
+  rawJudgeText: string;
+  parseError: string | null;
+};
+
+function splitSentences(text: string): string[] {
+  return text.replace(/\s+/g, " ").split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+}
+function splitParagraphs(text: string): string[] {
+  return text.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
+}
+function stdev(values: number[]): number {
+  if (values.length < 2) return 0;
+  const mean = values.reduce((a, b) => a + b, 0) / values.length;
+  const variance = values.reduce((a, b) => a + (b - mean) ** 2, 0) / values.length;
+  return Math.sqrt(variance);
+}
+function estimateSyllables(word: string): number {
+  const w = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (!w) return 0;
+  const matches = w.match(/[aeiouy]+/g);
+  let count = matches ? matches.length : 1;
+  if (w.endsWith("e") && count > 1) count -= 1;
+  return Math.max(1, count);
+}
+function fleschLabel(score: number): string {
+  if (score >= 90) return "Very easy (5th grade)";
+  if (score >= 80) return "Easy (6th grade)";
+  if (score >= 70) return "Fairly easy (7th grade)";
+  if (score >= 60) return "Standard (8th–9th grade)";
+  if (score >= 50) return "Fairly difficult (10th–12th grade)";
+  if (score >= 30) return "Difficult (college)";
+  return "Very difficult (graduate)";
+}
+
+/** Real, locally-computed prose metrics — no model call. */
+export function computeProseMetrics(text: string): ProseMetrics {
+  const body = text.replace(/^#{1,6}\s.*$/gm, "").trim();
+  const sentences = splitSentences(body);
+  const paragraphs = splitParagraphs(body);
+  const words = (body.match(/[A-Za-z']+/g) || []);
+  const wordCount = words.length;
+
+  const sentenceLens = sentences.map((s) => (s.match(/[A-Za-z']+/g) || []).length).filter((n) => n > 0);
+  const paraSentenceCounts = paragraphs.map((p) => splitSentences(p).length).filter((n) => n > 0);
+
+  const dialogueLines = sentences.filter((s) => /["“”]/.test(s)).length;
+  const dialogueRatio = sentences.length ? dialogueLines / sentences.length : 0;
+
+  const lowerWords = words.map((w) => w.toLowerCase());
+  const distinct = new Set(lowerWords).size;
+  const distinctWordRatio = lowerWords.length ? distinct / lowerWords.length : 0;
+
+  const syllables = words.reduce((a, w) => a + estimateSyllables(w), 0);
+  const fre = sentences.length && wordCount
+    ? 206.835 - 1.015 * (wordCount / sentences.length) - 84.6 * (syllables / wordCount)
+    : 0;
+  const fleschScore = Math.max(0, Math.min(100, Math.round(fre * 10) / 10));
+
+  // Repeated-phrase density: fraction of 5-gram shingles that are duplicates.
+  const shingle = lowerWords;
+  const grams = new Map<string, number>();
+  let total = 0;
+  for (let i = 0; i + 5 <= shingle.length; i += 1) {
+    const g = shingle.slice(i, i + 5).join(" ");
+    grams.set(g, (grams.get(g) ?? 0) + 1);
+    total += 1;
+  }
+  const dupGrams = Array.from(grams.values()).filter((n) => n > 1).reduce((a, n) => a + (n - 1), 0);
+  const repeatedPhraseDensity = total > 0 ? dupGrams / total : 0;
+
+  return {
+    wordCount,
+    sentenceCount: sentences.length,
+    paragraphCount: paragraphs.length,
+    avgSentenceLenWords: sentenceLens.length ? Math.round((sentenceLens.reduce((a, b) => a + b, 0) / sentenceLens.length) * 10) / 10 : 0,
+    sentenceLenStdev: Math.round(stdev(sentenceLens) * 10) / 10,
+    avgParagraphLenSentences: paraSentenceCounts.length ? Math.round((paraSentenceCounts.reduce((a, b) => a + b, 0) / paraSentenceCounts.length) * 10) / 10 : 0,
+    paragraphLenStdev: Math.round(stdev(paraSentenceCounts) * 10) / 10,
+    dialogueRatio: Math.round(dialogueRatio * 1000) / 1000,
+    distinctWordRatio: Math.round(distinctWordRatio * 1000) / 1000,
+    fleschReadingEase: fleschScore,
+    fleschLabel: fleschLabel(fleschScore),
+    repeatedPhraseDensity: Math.round(repeatedPhraseDensity * 1000) / 1000,
+  };
+}
+
+const RUBRIC_KEYS: (keyof JudgeRubricScores)[] = [
+  "plotStructure", "characterization", "proseStyle", "dialogue", "pacing",
+  "emotionalResonance", "thematicDepth", "realWorldRelation", "originality",
+  "readabilityJudgment", "marketability", "overall",
+];
+
+export function buildJudgePrompt(fullText: string, blueprint: SageBlueprint, metrics: ProseMetrics): string {
+  return [
+    "You are a senior acquisitions editor and developmental editor at a major trade publisher.",
+    "Grade the manuscript below exactly as a human professional reader would for an acquisitions or revision memo.",
+    "Score each category 1-10 (10 = publication-ready at a major house). Be a real critic: do not default to 7-8 for everything.",
+    "",
+    "COMPUTED PROSE METRICS (already measured by software, for your reference — do not re-derive):",
+    `- Words: ${metrics.wordCount}, Sentences: ${metrics.sentenceCount}, Paragraphs: ${metrics.paragraphCount}`,
+    `- Avg sentence length: ${metrics.avgSentenceLenWords} words (stdev ${metrics.sentenceLenStdev})`,
+    `- Avg paragraph length: ${metrics.avgParagraphLenSentences} sentences (stdev ${metrics.paragraphLenStdev})`,
+    `- Dialogue ratio: ${(metrics.dialogueRatio * 100).toFixed(1)}%`,
+    `- Distinct-word ratio: ${(metrics.distinctWordRatio * 100).toFixed(1)}% (lower = more repetitive)`,
+    `- Flesch Reading Ease: ${metrics.fleschReadingEase} (${metrics.fleschLabel})`,
+    `- Repeated 5-gram phrase density: ${(metrics.repeatedPhraseDensity * 100).toFixed(1)}%`,
+    "",
+    `MACRO STRUCTURE: ${blueprint.macro.name} | TONE: ${blueprint.tone} | THEME: ${blueprint.theme}`,
+    "",
+    "Respond with STRICT JSON only, no markdown fences, no commentary outside the JSON, matching exactly this shape:",
+    `{"scores":{"plotStructure":n,"characterization":n,"proseStyle":n,"dialogue":n,"pacing":n,"emotionalResonance":n,"thematicDepth":n,"realWorldRelation":n,"originality":n,"readabilityJudgment":n,"marketability":n,"overall":n},"justifications":{"plotStructure":"...","characterization":"...","proseStyle":"...","dialogue":"...","pacing":"...","emotionalResonance":"...","thematicDepth":"...","realWorldRelation":"...","originality":"...","readabilityJudgment":"...","marketability":"...","overall":"..."},"rewriteTargets":[{"scope":"chapter|scene|paragraph|sentence","location":"e.g. Chapter 3, second scene","issue":"...","suggestion":"..."}]}`,
+    "Provide 5-12 rewriteTargets spanning multiple scopes (some chapter-level, some scene-level, some sentence-level) exactly as a real manuscript editor's marginalia would.",
+    "",
+    "MANUSCRIPT:",
+    fullText.slice(0, 60000),
+  ].join("\n");
+}
+
+function extractJson(raw: string): unknown {
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) throw new Error("no JSON object found in judge response");
+  return JSON.parse(raw.slice(start, end + 1));
+}
+
+export function parseJudgeResponse(raw: string): {
+  rubric: JudgeRubricScores | null;
+  justifications: Partial<Record<keyof JudgeRubricScores, string>> | null;
+  rewriteTargets: RewriteTarget[];
+  parseError: string | null;
+} {
+  try {
+    const parsed = extractJson(raw) as {
+      scores?: Partial<Record<string, number>>;
+      justifications?: Partial<Record<string, string>>;
+      rewriteTargets?: unknown[];
+    };
+    const scoresIn = parsed.scores ?? {};
+    const rubric = {} as JudgeRubricScores;
+    for (const k of RUBRIC_KEYS) {
+      const v = Number(scoresIn[k]);
+      rubric[k] = Number.isFinite(v) ? Math.max(1, Math.min(10, v)) : 5;
+    }
+    const justifications: Partial<Record<keyof JudgeRubricScores, string>> = {};
+    for (const k of RUBRIC_KEYS) {
+      const j = parsed.justifications?.[k];
+      if (typeof j === "string") justifications[k] = j;
+    }
+    const rewriteTargets: RewriteTarget[] = Array.isArray(parsed.rewriteTargets)
+      ? (parsed.rewriteTargets as unknown[])
+          .filter((t): t is Record<string, unknown> => !!t && typeof t === "object")
+          .map((t) => ({
+            scope: (["chapter", "scene", "paragraph", "sentence"].includes(String(t.scope)) ? t.scope : "chapter") as RewriteTarget["scope"],
+            location: String(t.location ?? "unspecified"),
+            issue: String(t.issue ?? ""),
+            suggestion: String(t.suggestion ?? ""),
+          }))
+      : [];
+    return { rubric, justifications, rewriteTargets, parseError: null };
+  } catch (e) {
+    return { rubric: null, justifications: null, rewriteTargets: [], parseError: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+export type JudgeGenerateFn = (userMessage: string) => Promise<string>;
+
+export async function gradeManuscript(
+  fullText: string,
+  blueprint: SageBlueprint,
+  generate: JudgeGenerateFn,
+): Promise<ManuscriptGradeReport> {
+  const metrics = computeProseMetrics(fullText);
+  const prompt = buildJudgePrompt(fullText, blueprint, metrics);
+  const raw = await generate(prompt);
+  const parsed = parseJudgeResponse(raw);
+  return {
+    metrics,
+    rubric: parsed.rubric,
+    justifications: parsed.justifications,
+    rewriteTargets: parsed.rewriteTargets,
+    rawJudgeText: raw,
+    parseError: parsed.parseError,
+  };
+}

package/src/lib/sage/prng.ts

@@ -0,0 +1,53 @@
+/**
+ * SAGE PRNG — Mulberry32 (same family as Williams style persona).
+ * Deterministic: same seed ⇒ same sequence. No external deps.
+ */
+
+export function mulberry32(seed: number): () => number {
+  let s = seed | 0;
+  return () => {
+    s = (s + 0x6d2b79f5) | 0;
+    let t = Math.imul(s ^ (s >>> 15), 1 | s);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export function randRange(rng: () => number, lo: number, hi: number): number {
+  return lo + rng() * (hi - lo);
+}
+
+export function randPick<T>(rng: () => number, arr: readonly T[]): T {
+  return arr[Math.floor(rng() * arr.length) % arr.length];
+}
+
+export function randPickN<T>(rng: () => number, arr: readonly T[], n: number): T[] {
+  const copy = arr.slice();
+  const out: T[] = [];
+  const count = Math.min(n, copy.length);
+  for (let i = 0; i < count; i += 1) {
+    const idx = Math.floor(rng() * copy.length);
+    out.push(copy.splice(idx, 1)[0]);
+  }
+  return out;
+}
+
+export function newSageSeed(): number {
+  return (Math.floor(Math.random() * 0xffffffff) >>> 0) || 1;
+}
+
+/** FNV-1a + xorshift mix — matches innovation-genome determinism pattern. */
+export function mix32(seed: number, index: number): number {
+  const s = `${seed}:${index}`;
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  h ^= h >>> 16;
+  h = Math.imul(h, 0x7feb352d) >>> 0;
+  h ^= h >>> 15;
+  h = Math.imul(h, 0x846ca68b) >>> 0;
+  h ^= h >>> 16;
+  return h >>> 0;
+}