@gobing-ai/knowledge-kit 0.0.11 → 0.0.13

package/plugins/generations/content-gen/plugin.json

@@ -1,7 +1,7 @@
 {
     "name": "content-gen",
     "kind": "generator",
-    "entry": "./src/index.ts",
+    "entry": "./dist/index.js",
     "version": "1.0.0",
     "description": "Generator plugin running the owned STORM pipeline (curation, outline, article, polish) to produce Doc[] → Content"
 }

package/plugins/generations/content-gen/src/storm.ts

@@ -1,4 +1,5 @@
 import { type Content, ContentSchema, type Doc } from '@gobing-ai/kk-core';
+import { echoError } from '@gobing-ai/ts-utils';
 import { z } from 'zod';
 import { parseAgentJson } from './agent-json';
 
@@ -21,60 +22,97 @@ export interface StormStageRunner {
     runStage(prompt: string): Promise<AgentRunEnvelope>;
 }
 
-/** Concrete runner invoking the existing `spur agent run` boundary (same call shape as the D2 stand-in). */
-export const spurStageRunner: StormStageRunner = {
-    async runStage(prompt: string): Promise<AgentRunEnvelope> {
-        const proc = Bun.spawn(
-            [
-                process.env.KNOWLEDGE_KIT_SPUR_BIN ?? 'spur',
-                'agent',
-                'run',
-                prompt,
-                '--agent',
-                'auto',
-                '--mode',
-                'text',
-                '--json',
-                '--cwd',
-                process.cwd(),
-            ],
-            { stdout: 'pipe', stderr: 'pipe' },
-        );
-        const [exitCode, stdout, stderr] = await Promise.all([
-            proc.exited,
-            new Response(proc.stdout).text(),
-            new Response(proc.stderr).text(),
-        ]);
-        if (exitCode !== 0) {
-            // CLI-level failure (spawn/argv): no envelope to unwrap; stages prefix the diagnostic.
-            return { exitCode, stdout, stderr };
+interface SpawnOutcome {
+    kind: 'ok' | 'crash' | 'malformed';
+    envelope: AgentRunEnvelope;
+}
+
+/** One `spur agent run` invocation + envelope unwrap. */
+async function spawnAgentOnce(prompt: string): Promise<SpawnOutcome> {
+    const proc = Bun.spawn(
+        [
+            process.env.KNOWLEDGE_KIT_SPUR_BIN ?? 'spur',
+            'agent',
+            'run',
+            prompt,
+            '--agent',
+            'auto',
+            '--mode',
+            'text',
+            '--json',
+            '--cwd',
+            // Anchor the agent's cwd to the project root (set by the executor, whose own
+            // cwd is the invocation root). process.cwd() here is the plugin package dir —
+            // using it makes spur auto-init a stray `.spur/` and drops agent files there.
+            process.env.KNOWLEDGE_KIT_PROJECT_ROOT ?? process.cwd(),
+        ],
+        { stdout: 'pipe', stderr: 'pipe' },
+    );
+    const [exitCode, stdout, stderr] = await Promise.all([
+        proc.exited,
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+    ]);
+    if (exitCode !== 0) {
+        // CLI-level failure (spawn/argv): no envelope to unwrap; stages prefix the diagnostic.
+        return { kind: 'crash', envelope: { exitCode, stdout, stderr } };
+    }
+    // The CLI writes the agent envelope {exitCode, stdout, stderr, durationMs} to stdout.
+    // Unwrap it so stages consume the agent output.
+    try {
+        const parsed = JSON.parse(stdout) as Partial<AgentRunEnvelope>;
+        if (
+            typeof parsed.exitCode !== 'number' ||
+            typeof parsed.stdout !== 'string' ||
+            typeof parsed.stderr !== 'string'
+        ) {
+            throw new Error('expected envelope {exitCode:number, stdout:string, stderr:string}');
         }
-        // The CLI writes the agent envelope {exitCode, stdout, stderr, durationMs} to stdout.
-        // Unwrap it so stages consume the agent output.
-        let envelope: AgentRunEnvelope;
-        try {
-            const parsed = JSON.parse(stdout) as Partial<AgentRunEnvelope>;
-            if (
-                typeof parsed.exitCode !== 'number' ||
-                typeof parsed.stdout !== 'string' ||
-                typeof parsed.stderr !== 'string'
-            ) {
-                throw new Error('expected envelope {exitCode:number, stdout:string, stderr:string}');
-            }
-            envelope = parsed as AgentRunEnvelope;
-        } catch (error) {
-            // Exit-0 but non-envelope stdout: return a runner-level diagnostic so the calling
-            // stage prefixes it ({Stage} stage failed: …) instead of leaking a raw SyntaxError.
-            return {
+        const envelope = parsed as AgentRunEnvelope;
+        return { kind: envelope.exitCode === 0 ? 'ok' : 'crash', envelope };
+    } catch (error) {
+        // Exit-0 but non-envelope stdout: deterministic contract failure — never retried.
+        return {
+            kind: 'malformed',
+            envelope: {
                 exitCode: 1,
                 stdout: '',
                 stderr: `spur agent run returned malformed output: ${error instanceof Error ? error.message : String(error)}`,
-            };
+            },
+        };
+    }
+}
+
+/** Concrete runner invoking the existing `spur agent run` boundary (same call shape as the D2 stand-in). */
+export const spurStageRunner: StormStageRunner = {
+    async runStage(prompt: string): Promise<AgentRunEnvelope> {
+        // A crashed agent subprocess (e.g. polish stage exit 1, dogfood daily-ai-news-20260903)
+        // must not kill a 90-minute pipeline run — retry once. Malformed envelopes are a
+        // deterministic contract failure and are not retried.
+        let last: AgentRunEnvelope = { exitCode: 1, stdout: '', stderr: 'no attempt executed' };
+        for (let attempt = 1; attempt <= 2; attempt++) {
+            const outcome = await spawnAgentOnce(prompt);
+            if (outcome.kind !== 'crash') return outcome.envelope;
+            last = outcome.envelope;
+            if (attempt === 1) {
+                echoError(
+                    `spurStageRunner: agent run exited ${last.exitCode}; retrying once (${last.stderr.trim().slice(0, 200)})`,
+                );
+            }
         }
-        return { exitCode: envelope.exitCode, stdout: envelope.stdout, stderr: envelope.stderr };
+        return last;
     },
 };
 
+/** Language directive appended to outline/article/polish prompts when CONTENT_LANGUAGE is set. */
+function languageDirective(): string {
+    const lang = process.env.CONTENT_LANGUAGE?.trim();
+    if (!lang) return '';
+    return lang === 'zh'
+        ? 'Write everything in Simplified Chinese (简体中文), including the title and all section headings.'
+        : `Write everything in ${lang}, including the title and all section headings.`;
+}
+
 const PerspectiveSchema = z.object({
     id: z.string().min(1),
     name: z.string().min(1),
@@ -166,7 +204,9 @@ export async function curationStage(runner: StormStageRunner, docs: Doc[], input
         [
             'Develop multiple distinct perspectives (personas or angles) on the source material. For each perspective, list the questions it would ask and cite the supplied document IDs that ground it.',
             'Return only a JSON object matching {"perspectives":[{"id":string,"name":string,"questions":[string],"evidence":[string]}]} where every evidence entry is one of the allowed document IDs.',
-        ].join('\n'),
+        ]
+            .filter(Boolean)
+            .join('\n'),
     );
     const envelope = await runner.runStage(prompt);
     if (envelope.exitCode !== 0) {
@@ -204,8 +244,11 @@ export async function outlineStage(
         [
             `The validated curation result for the article is: ${JSON.stringify(curation)}`,
             'Produce a structured markdown outline for the article derived from that curation result.',
+            languageDirective(),
             'Return only a JSON object matching {"title":string,"outline":string,"references":[string]} where outline is markdown and every references entry is one of the allowed document IDs.',
-        ].join('\n'),
+        ]
+            .filter(Boolean)
+            .join('\n'),
     );
     const envelope = await runner.runStage(prompt);
     if (envelope.exitCode !== 0) {
@@ -242,9 +285,12 @@ export async function articleStage(
             `The validated curation result for the article is: ${JSON.stringify(curation)}`,
             `The validated outline for the article is: ${JSON.stringify(outline)}`,
             'Write the complete article as markdown, one section per outline heading. Every citation must reference one of the allowed document IDs.',
+            languageDirective(),
             'Synthesize: the body must draw findings from across the supplied documents, compare them, and state conclusions. Never list sources one per line or produce an index of references — references are evidence, not the deliverable.',
             'Return only a JSON object matching {"title":string,"body":string,"citations":[string]} where body is the full markdown draft and every citations entry is one of the allowed document IDs.',
-        ].join('\n'),
+        ]
+            .filter(Boolean)
+            .join('\n'),
     );
     const envelope = await runner.runStage(prompt);
     if (envelope.exitCode !== 0) {
@@ -278,8 +324,11 @@ export async function polishStage(
         [
             `The drafted article is: ${JSON.stringify(article)}`,
             'Polish the draft: preserve every heading and citation exactly, remove repetition, and tighten the prose. Do not cite any document outside the allowed IDs.',
+            languageDirective(),
             'Return only a JSON object matching {"title":string,"body":string,"outline":string} where body is the polished markdown (headings and citations preserved) and outline is a markdown outline of the final article.',
-        ].join('\n'),
+        ]
+            .filter(Boolean)
+            .join('\n'),
     );
     const envelope = await runner.runStage(prompt);
     if (envelope.exitCode !== 0) {