@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/core/src/models/input-governance.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+
+export const ChapterMemoSchema = z.object({
+  chapter: z.number().int().min(1),
+  goal: z.string().min(1).max(50),
+  isGoldenOpening: z.boolean().default(false),
+  body: z.string().min(1),
+  threadRefs: z.array(z.string()).default([]),
+});
+
+export type ChapterMemo = z.infer<typeof ChapterMemoSchema>;
+
+export const ChapterIntentSchema = z.object({
+  chapter: z.number().int().min(1),
+  goal: z.string().min(1),
+  outlineNode: z.string().optional(),
+  arcContext: z.string().optional(),
+  mustKeep: z.array(z.string()).default([]),
+  mustAvoid: z.array(z.string()).default([]),
+  styleEmphasis: z.array(z.string()).default([]),
+});
+
+export type ChapterIntent = z.infer<typeof ChapterIntentSchema>;
+
+export const ContextSourceSchema = z.object({
+  source: z.string().min(1),
+  reason: z.string().min(1),
+  excerpt: z.string().optional(),
+});
+
+export type ContextSource = z.infer<typeof ContextSourceSchema>;
+
+export const ContextPackageSchema = z.object({
+  chapter: z.number().int().min(1),
+  selectedContext: z.array(ContextSourceSchema).default([]),
+});
+
+export type ContextPackage = z.infer<typeof ContextPackageSchema>;
+
+export const RuleLayerScopeSchema = z.enum(["global", "book", "arc", "local"]);
+export type RuleLayerScope = z.infer<typeof RuleLayerScopeSchema>;
+
+export const RuleLayerSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  precedence: z.number().int(),
+  scope: RuleLayerScopeSchema,
+});
+
+export type RuleLayer = z.infer<typeof RuleLayerSchema>;
+
+export const OverrideEdgeSchema = z.object({
+  from: z.string().min(1),
+  to: z.string().min(1),
+  allowed: z.boolean(),
+  scope: z.string().min(1),
+});
+
+export type OverrideEdge = z.infer<typeof OverrideEdgeSchema>;
+
+export const ActiveOverrideSchema = z.object({
+  from: z.string().min(1),
+  to: z.string().min(1),
+  target: z.string().min(1),
+  reason: z.string().min(1),
+});
+
+export type ActiveOverride = z.infer<typeof ActiveOverrideSchema>;
+
+export const RuleStackSectionsSchema = z.object({
+  hard: z.array(z.string()).default([]),
+  soft: z.array(z.string()).default([]),
+  diagnostic: z.array(z.string()).default([]),
+});
+
+export type RuleStackSections = z.infer<typeof RuleStackSectionsSchema>;
+
+export const RuleStackSchema = z.object({
+  layers: z.array(RuleLayerSchema).min(1),
+  sections: RuleStackSectionsSchema.default({
+    hard: [],
+    soft: [],
+    diagnostic: [],
+  }),
+  overrideEdges: z.array(OverrideEdgeSchema).default([]),
+  activeOverrides: z.array(ActiveOverrideSchema).default([]),
+});
+
+export type RuleStack = z.infer<typeof RuleStackSchema>;
+
+export const ChapterTraceSchema = z.object({
+  chapter: z.number().int().min(1),
+  plannerInputs: z.array(z.string()),
+  composerInputs: z.array(z.string()),
+  selectedSources: z.array(z.string()),
+  notes: z.array(z.string()).default([]),
+});
+
+export type ChapterTrace = z.infer<typeof ChapterTraceSchema>;

package/inkos/packages/core/src/models/length-governance.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+
+export const LengthCountingModeSchema = z.enum(["zh_chars", "en_words"]);
+export type LengthCountingMode = z.infer<typeof LengthCountingModeSchema>;
+
+export const LengthNormalizeModeSchema = z.enum(["expand", "compress", "none"]);
+export type LengthNormalizeMode = z.infer<typeof LengthNormalizeModeSchema>;
+
+export const LengthSpecSchema = z.object({
+  target: z.number().int().min(1),
+  softMin: z.number().int().min(1),
+  softMax: z.number().int().min(1),
+  hardMin: z.number().int().min(1),
+  hardMax: z.number().int().min(1),
+  countingMode: LengthCountingModeSchema,
+  normalizeMode: LengthNormalizeModeSchema,
+});
+
+export type LengthSpec = z.infer<typeof LengthSpecSchema>;
+
+export const LengthTelemetrySchema = z.object({
+  target: z.number().int().min(1),
+  softMin: z.number().int().min(1),
+  softMax: z.number().int().min(1),
+  hardMin: z.number().int().min(1),
+  hardMax: z.number().int().min(1),
+  countingMode: LengthCountingModeSchema,
+  writerCount: z.number().int().min(0),
+  postWriterNormalizeCount: z.number().int().min(0),
+  postReviseCount: z.number().int().min(0),
+  finalCount: z.number().int().min(0),
+  normalizeApplied: z.boolean(),
+  lengthWarning: z.boolean(),
+});
+
+export type LengthTelemetry = z.infer<typeof LengthTelemetrySchema>;
+
+export const LengthWarningSchema = z.object({
+  chapter: z.number().int().min(1),
+  target: z.number().int().min(1),
+  actual: z.number().int().min(0),
+  countingMode: LengthCountingModeSchema,
+  reason: z.string().min(1),
+});
+
+export type LengthWarning = z.infer<typeof LengthWarningSchema>;

package/inkos/packages/core/src/models/project.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+
+// C1 (v2.0.0 breaking): `maxTokens` 字段已被 providers bank 接管；zod 用 strip mode 静默丢弃老配置里的 `maxTokens`。
+const LLMServiceEntrySchema = z.object({
+  service: z.string().min(1),
+  name: z.string().min(1).optional(),
+  baseUrl: z.string().url().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  apiFormat: z.enum(["chat", "responses"]).optional(),
+  stream: z.boolean().optional(),
+});
+
+const LLMCoverConfigSchema = z.object({
+  service: z.enum(["kkaiapi", "openai", "google"]),
+  model: z.string().min(1),
+}).optional();
+
+// C1 (v2.0.0 breaking): 删除 maxTokens / maxTokensCap 字段。
+// 每个模型的真实 maxOutput 来自 providers/<name>.ts 的 InkosModel.maxOutput；
+// 老配置里写的 maxTokens / maxTokensCap 会被 zod strip 静默丢弃（不报错）。
+export const LLMConfigSchema = z.object({
+  provider: z.enum(["anthropic", "openai", "custom"]),
+  service: z.string().default("custom"),
+  configSource: z.enum(["env", "studio"]).default("env"),
+  baseUrl: z.string().url(),
+  apiKey: z.string().default(""),
+  model: z.string().min(1),
+  proxyUrl: z.string().url().optional(),
+  temperature: z.number().min(0).max(2).default(0.7),
+  thinkingBudget: z.number().int().min(0).default(0),
+  extra: z.record(z.unknown()).optional(),
+  headers: z.record(z.string()).optional(),
+  apiFormat: z.enum(["chat", "responses"]).default("chat"),
+  stream: z.boolean().default(true),
+  services: z.array(LLMServiceEntrySchema).optional(),
+  defaultModel: z.string().min(1).optional(),
+  cover: LLMCoverConfigSchema,
+});
+
+export type LLMConfig = z.infer<typeof LLMConfigSchema>;
+
+export const NotifyChannelSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("telegram"),
+    botToken: z.string().min(1),
+    chatId: z.string().min(1),
+  }),
+  z.object({
+    type: z.literal("wechat-work"),
+    webhookUrl: z.string().url(),
+  }),
+  z.object({
+    type: z.literal("feishu"),
+    webhookUrl: z.string().url(),
+  }),
+  z.object({
+    type: z.literal("webhook"),
+    url: z.string().url(),
+    secret: z.string().optional(),
+    events: z.array(z.string()).default([]),
+  }),
+]);
+
+export type NotifyChannel = z.infer<typeof NotifyChannelSchema>;
+
+export const DetectionConfigSchema = z.object({
+  provider: z.enum(["gptzero", "originality", "custom", "local", "llm"]).default("llm"),
+  apiUrl: z.string().url().optional(),
+  apiKeyEnv: z.string().min(1).optional(),
+  threshold: z.number().min(0).max(1).default(0.5),
+  enabled: z.boolean().default(false),
+  autoRewrite: z.boolean().default(false),
+  maxRetries: z.number().int().min(1).max(10).default(3),
+});
+
+export type DetectionConfig = z.infer<typeof DetectionConfigSchema>;
+
+export const QualityGatesSchema = z.object({
+  maxAuditRetries: z.number().int().min(0).max(10).default(2),
+  pauseAfterConsecutiveFailures: z.number().int().min(1).default(3),
+  retryTemperatureStep: z.number().min(0).max(0.5).default(0.1),
+});
+
+export type QualityGates = z.infer<typeof QualityGatesSchema>;
+
+export const FoundationConfigSchema = z.object({
+  reviewRetries: z.number().int().min(0).max(10).default(2),
+});
+
+export type FoundationConfig = z.infer<typeof FoundationConfigSchema>;
+
+export const WritingConfigSchema = z.object({
+  reviewRetries: z.number().int().min(0).max(10).default(1),
+});
+
+export type WritingConfig = z.infer<typeof WritingConfigSchema>;
+
+export const AgentLLMOverrideSchema = z.object({
+  model: z.string().min(1),
+  provider: z.enum(["anthropic", "openai", "custom"]).optional(),
+  baseUrl: z.string().url().optional(),
+  apiKeyEnv: z.string().optional(),
+  stream: z.boolean().optional(),
+});
+
+export type AgentLLMOverride = z.infer<typeof AgentLLMOverrideSchema>;
+
+export const InputGovernanceModeSchema = z.enum(["legacy", "v2"]);
+export type InputGovernanceMode = z.infer<typeof InputGovernanceModeSchema>;
+
+const ModelOverrideValueSchema = z.union([z.string(), AgentLLMOverrideSchema]);
+
+export const ProjectConfigSchema = z.object({
+  name: z.string().min(1),
+  version: z.literal("0.1.0"),
+  language: z.enum(["zh", "en"]).default("zh"),
+  llm: LLMConfigSchema,
+  notify: z.array(NotifyChannelSchema).default([]),
+  detection: DetectionConfigSchema.optional(),
+  foundation: FoundationConfigSchema.default({
+    reviewRetries: 2,
+  }),
+  writing: WritingConfigSchema.default({
+    reviewRetries: 1,
+  }),
+  modelOverrides: z.record(z.string(), ModelOverrideValueSchema).optional(),
+  inputGovernanceMode: InputGovernanceModeSchema.default("v2"),
+  daemon: z.object({
+    schedule: z.object({
+      radarCron: z.string().default("0 */6 * * *"),
+      writeCron: z.string().default("*/15 * * * *"),
+    }),
+    maxConcurrentBooks: z.number().int().min(1).default(3),
+    chaptersPerCycle: z.number().int().min(1).max(20).default(1),
+    retryDelayMs: z.number().int().min(0).default(30_000),
+    cooldownAfterChapterMs: z.number().int().min(0).default(10_000),
+    maxChaptersPerDay: z.number().int().min(1).default(50),
+    qualityGates: QualityGatesSchema.default({
+      maxAuditRetries: 2,
+      pauseAfterConsecutiveFailures: 3,
+      retryTemperatureStep: 0.1,
+    }),
+  }).default({
+    schedule: {
+      radarCron: "0 */6 * * *",
+      writeCron: "*/15 * * * *",
+    },
+    maxConcurrentBooks: 3,
+    chaptersPerCycle: 1,
+    retryDelayMs: 30_000,
+    cooldownAfterChapterMs: 10_000,
+    maxChaptersPerDay: 50,
+    qualityGates: {
+      maxAuditRetries: 2,
+      pauseAfterConsecutiveFailures: 3,
+      retryTemperatureStep: 0.1,
+    },
+  }),
+});
+
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;

package/inkos/packages/core/src/models/runtime-state.ts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+
+export const RuntimeStateLanguageSchema = z.enum(["zh", "en"]);
+export type RuntimeStateLanguage = z.infer<typeof RuntimeStateLanguageSchema>;
+
+export const StateManifestSchema = z.object({
+  schemaVersion: z.literal(2),
+  language: RuntimeStateLanguageSchema,
+  lastAppliedChapter: z.number().int().min(0),
+  projectionVersion: z.number().int().min(1),
+  migrationWarnings: z.array(z.string()).default([]),
+});
+
+export type StateManifest = z.infer<typeof StateManifestSchema>;
+
+export const HookStatusSchema = z.enum(["open", "progressing", "deferred", "resolved"]);
+export type HookStatus = z.infer<typeof HookStatusSchema>;
+
+export const HookPayoffTimingSchema = z.enum([
+  "immediate",
+  "near-term",
+  "mid-arc",
+  "slow-burn",
+  "endgame",
+]);
+export type HookPayoffTiming = z.infer<typeof HookPayoffTimingSchema>;
+
+export const HookRecordSchema = z.object({
+  hookId: z.string().min(1),
+  startChapter: z.number().int().min(0),
+  type: z.string().min(1),
+  status: HookStatusSchema,
+  lastAdvancedChapter: z.number().int().min(0),
+  expectedPayoff: z.string().default(""),
+  payoffTiming: HookPayoffTimingSchema.optional(),
+  notes: z.string().default(""),
+  // Phase 7 — hook causality / promotion metadata.
+  // All optional so hooks parsed from pre-Phase-7 markdown still validate
+  // and so callers constructing HookRecord inline can omit them.
+  dependsOn: z.array(z.string().min(1)).optional(),
+  paysOffInArc: z.string().optional(),
+  coreHook: z.boolean().optional(),
+  halfLifeChapters: z.number().int().positive().optional(),
+  advancedCount: z.number().int().min(0).optional(),
+  // Phase 7 hotfix 2 — promotion flag. Undefined on legacy 11/12-column
+  // ledgers; architect-seed and consolidator-rerun both populate it going
+  // forward. Reviewer uses it to gate critical severity for stale hooks.
+  promoted: z.boolean().optional(),
+});
+
+export type HookRecord = z.infer<typeof HookRecordSchema>;
+
+export const HooksStateSchema = z.object({
+  hooks: z.array(HookRecordSchema).default([]),
+});
+
+export type HooksState = z.infer<typeof HooksStateSchema>;
+
+export const ChapterSummaryRowSchema = z.object({
+  chapter: z.number().int().min(1),
+  title: z.string().min(1),
+  characters: z.string().default(""),
+  events: z.string().default(""),
+  stateChanges: z.string().default(""),
+  hookActivity: z.string().default(""),
+  mood: z.string().default(""),
+  chapterType: z.string().default(""),
+});
+
+export type ChapterSummaryRow = z.infer<typeof ChapterSummaryRowSchema>;
+
+export const ChapterSummariesStateSchema = z.object({
+  rows: z.array(ChapterSummaryRowSchema).default([]),
+});
+
+export type ChapterSummariesState = z.infer<typeof ChapterSummariesStateSchema>;
+
+export const CurrentStateFactSchema = z.object({
+  subject: z.string().min(1),
+  predicate: z.string().min(1),
+  object: z.string().min(1),
+  validFromChapter: z.number().int().min(0),
+  validUntilChapter: z.number().int().min(0).nullable(),
+  sourceChapter: z.number().int().min(0),
+});
+
+export type CurrentStateFact = z.infer<typeof CurrentStateFactSchema>;
+
+export const CurrentStateStateSchema = z.object({
+  chapter: z.number().int().min(0),
+  facts: z.array(CurrentStateFactSchema).default([]),
+});
+
+export type CurrentStateState = z.infer<typeof CurrentStateStateSchema>;
+
+export const CurrentStatePatchSchema = z.object({
+  currentLocation: z.string().optional(),
+  protagonistState: z.string().optional(),
+  currentGoal: z.string().optional(),
+  currentConstraint: z.string().optional(),
+  currentAlliances: z.string().optional(),
+  currentConflict: z.string().optional(),
+});
+
+export type CurrentStatePatch = z.infer<typeof CurrentStatePatchSchema>;
+
+export const HookOpsSchema = z.object({
+  upsert: z.array(HookRecordSchema).default([]),
+  mention: z.array(z.string().min(1)).default([]),
+  resolve: z.array(z.string().min(1)).default([]),
+  defer: z.array(z.string().min(1)).default([]),
+});
+
+export type HookOps = z.infer<typeof HookOpsSchema>;
+
+export const NewHookCandidateSchema = z.object({
+  type: z.string().min(1),
+  expectedPayoff: z.string().default(""),
+  payoffTiming: HookPayoffTimingSchema.optional(),
+  notes: z.string().default(""),
+});
+
+export type NewHookCandidate = z.infer<typeof NewHookCandidateSchema>;
+
+const LooseOpSchema = z.record(z.string(), z.unknown());
+
+export const RuntimeStateDeltaSchema = z.object({
+  chapter: z.number().int().min(1),
+  currentStatePatch: CurrentStatePatchSchema.optional(),
+  hookOps: HookOpsSchema.default({
+    upsert: [],
+    mention: [],
+    resolve: [],
+    defer: [],
+  }),
+  newHookCandidates: z.array(NewHookCandidateSchema).default([]),
+  chapterSummary: ChapterSummaryRowSchema.optional(),
+  subplotOps: z.array(LooseOpSchema).default([]),
+  emotionalArcOps: z.array(LooseOpSchema).default([]),
+  characterMatrixOps: z.array(LooseOpSchema).default([]),
+  notes: z.array(z.string()).default([]),
+});
+
+export type RuntimeStateDelta = z.infer<typeof RuntimeStateDeltaSchema>;

package/inkos/packages/core/src/models/state.ts

@@ -0,0 +1,52 @@
+/**
+ * Canonical state files — the three sources of truth per book.
+ * These are persisted as markdown files but parsed/validated here.
+ */
+
+export interface CurrentState {
+  readonly chapter: number;
+  readonly location: string;
+  readonly protagonist: {
+    readonly status: string;
+    readonly currentGoal: string;
+    readonly constraints: string;
+  };
+  readonly enemies: ReadonlyArray<{
+    readonly name: string;
+    readonly relationship: string;
+    readonly threat: string;
+  }>;
+  readonly knownTruths: ReadonlyArray<string>;
+  readonly currentConflict: string;
+  readonly anchor: string;
+}
+
+export interface LedgerEntry {
+  readonly chapter: number;
+  readonly openingValue: number;
+  readonly source: string;
+  readonly resourceCompleteness: string;
+  readonly delta: number;
+  readonly closingValue: number;
+  readonly basis: string;
+}
+
+export interface ParticleLedger {
+  readonly hardCap: number;
+  readonly currentTotal: number;
+  readonly entries: ReadonlyArray<LedgerEntry>;
+}
+
+export interface PendingHook {
+  readonly id: string;
+  readonly originChapter: number;
+  readonly type: string;
+  readonly status: "open" | "progressing" | "resolved";
+  readonly lastProgress: string;
+  readonly expectedResolution: string;
+  readonly note: string;
+}
+
+export interface PendingHooks {
+  readonly hooks: ReadonlyArray<PendingHook>;
+}

package/inkos/packages/core/src/models/style-profile.ts

@@ -0,0 +1,15 @@
+/** Style fingerprint profile extracted from reference text. */
+export interface StyleProfile {
+  readonly avgSentenceLength: number;
+  readonly sentenceLengthStdDev: number;
+  readonly avgParagraphLength: number;
+  readonly paragraphLengthRange: {
+    readonly min: number;
+    readonly max: number;
+  };
+  readonly vocabularyDiversity: number; // TTR (Type-Token Ratio)
+  readonly topPatterns: ReadonlyArray<string>;
+  readonly rhetoricalFeatures: ReadonlyArray<string>;
+  readonly sourceName?: string;
+  readonly analyzedAt?: string;
+}

package/inkos/packages/core/src/notify/dispatcher.ts

@@ -0,0 +1,96 @@
+import type { NotifyChannel } from "../models/project.js";
+import type { WebhookPayload } from "./webhook.js";
+
+export interface NotifyMessage {
+  readonly title: string;
+  readonly body: string;
+}
+
+export async function dispatchNotification(
+  channels: ReadonlyArray<NotifyChannel>,
+  message: NotifyMessage,
+): Promise<void> {
+  const fullText = `**${message.title}**\n\n${message.body}`;
+
+  const tasks = channels.map(async (channel) => {
+    try {
+      switch (channel.type) {
+        case "telegram":
+          {
+            const { sendTelegram } = await import("./telegram.js");
+            await sendTelegram(
+              { botToken: channel.botToken, chatId: channel.chatId },
+              fullText,
+            );
+          }
+          break;
+        case "feishu":
+          {
+            const { sendFeishu } = await import("./feishu.js");
+            await sendFeishu(
+              { webhookUrl: channel.webhookUrl },
+              message.title,
+              message.body,
+            );
+          }
+          break;
+        case "wechat-work":
+          {
+            const { sendWechatWork } = await import("./wechat-work.js");
+            await sendWechatWork(
+              { webhookUrl: channel.webhookUrl },
+              fullText,
+            );
+          }
+          break;
+        case "webhook":
+          // Webhook channels are handled by dispatchWebhookEvent for structured events.
+          // For generic text notifications, send as a pipeline-complete event.
+          {
+            const { sendWebhook } = await import("./webhook.js");
+            await sendWebhook(
+              { url: channel.url, secret: channel.secret, events: channel.events },
+              {
+                event: "pipeline-complete",
+                bookId: "",
+                timestamp: new Date().toISOString(),
+                data: { title: message.title, body: message.body },
+              },
+            );
+          }
+          break;
+      }
+    } catch (e) {
+      // Log but don't throw — notification failure shouldn't block pipeline
+      process.stderr.write(
+        `[notify] ${channel.type} failed: ${e}\n`,
+      );
+    }
+  });
+
+  await Promise.all(tasks);
+}
+
+/** Dispatch a structured webhook event to all webhook channels. */
+export async function dispatchWebhookEvent(
+  channels: ReadonlyArray<NotifyChannel>,
+  payload: WebhookPayload,
+): Promise<void> {
+  const webhookChannels = channels.filter((ch) => ch.type === "webhook");
+  if (webhookChannels.length === 0) return;
+
+  const tasks = webhookChannels.map(async (channel) => {
+    if (channel.type !== "webhook") return;
+    try {
+      const { sendWebhook } = await import("./webhook.js");
+      await sendWebhook(
+        { url: channel.url, secret: channel.secret, events: channel.events },
+        payload,
+      );
+    } catch (e) {
+      process.stderr.write(`[webhook] ${channel.url} failed: ${e}\n`);
+    }
+  });
+
+  await Promise.all(tasks);
+}

package/inkos/packages/core/src/notify/feishu.ts

@@ -0,0 +1,34 @@
+export interface FeishuConfig {
+  readonly webhookUrl: string;
+}
+
+export async function sendFeishu(
+  config: FeishuConfig,
+  title: string,
+  content: string,
+): Promise<void> {
+  const response = await fetch(config.webhookUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      msg_type: "interactive",
+      card: {
+        header: {
+          title: { tag: "plain_text", content: title },
+          template: "blue",
+        },
+        elements: [
+          {
+            tag: "markdown",
+            content,
+          },
+        ],
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Feishu send failed: ${response.status} ${body}`);
+  }
+}

package/inkos/packages/core/src/notify/telegram.ts

@@ -0,0 +1,25 @@
+export interface TelegramConfig {
+  readonly botToken: string;
+  readonly chatId: string;
+}
+
+export async function sendTelegram(
+  config: TelegramConfig,
+  message: string,
+): Promise<void> {
+  const url = `https://api.telegram.org/bot${config.botToken}/sendMessage`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      chat_id: config.chatId,
+      text: message,
+      parse_mode: "Markdown",
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Telegram send failed: ${response.status} ${body}`);
+  }
+}