deepclause-pi 0.2.0 → 0.4.0

package/src/config.ts

@@ -2,6 +2,21 @@ import { readFile, writeFile } from "node:fs/promises";
 
 export type ContextMode = "turn" | "branch" | "isolated";
 
+export interface JevJudgeConfig {
+  /** Whether the Jev (TypeSafe System One) backend may be used. */
+  enabled: boolean;
+  /** Model alias or pinned version passed to TypeSafe. */
+  model: string;
+  /** Environment variable holding the TypeSafe API key. */
+  apiKeyEnv: string;
+}
+
+export interface JudgmentConfig {
+  /** Default backend name: "llm", "jev", or a name registered by an extension. */
+  default: string;
+  jev: JevJudgeConfig;
+}
+
 export interface DeepClauseConfig {
   version: 1;
   contextMode: ContextMode;
@@ -10,6 +25,7 @@ export interface DeepClauseConfig {
   maxTokens: number;
   verbose: boolean;
   modelToolEnabled: boolean;
+  judgment: JudgmentConfig;
 }
 
 export const DEFAULT_CONFIG: DeepClauseConfig = {
@@ -20,6 +36,10 @@ export const DEFAULT_CONFIG: DeepClauseConfig = {
   maxTokens: 16_384,
   verbose: false,
   modelToolEnabled: false,
+  judgment: {
+    default: "llm",
+    jev: { enabled: false, model: "jev-latest", apiKeyEnv: "TYPESAFE_API_KEY" },
+  },
 };
 
 const isContextMode = (value: unknown): value is ContextMode =>
@@ -55,6 +75,42 @@ export async function loadConfig(path: string): Promise<DeepClauseConfig> {
     maxTokens: positiveInteger("maxTokens", DEFAULT_CONFIG.maxTokens),
     verbose: config.verbose === true,
     modelToolEnabled: config.modelToolEnabled === true,
+    judgment: parseJudgmentConfig(config.judgment),
+  };
+}
+
+function parseJudgmentConfig(value: unknown): JudgmentConfig {
+  if (value === undefined) return DEFAULT_CONFIG.judgment;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("judgment must be a JSON object");
+  }
+  const judgment = value as Record<string, unknown>;
+  const defaultBackend = judgment.default ?? DEFAULT_CONFIG.judgment.default;
+  if (typeof defaultBackend !== "string" || !defaultBackend.trim()) {
+    throw new Error("judgment.default must be a non-empty backend name");
+  }
+
+  const jevValue = judgment.jev ?? {};
+  if (!jevValue || typeof jevValue !== "object" || Array.isArray(jevValue)) {
+    throw new Error("judgment.jev must be a JSON object");
+  }
+  const jev = jevValue as Record<string, unknown>;
+  const model = jev.model ?? DEFAULT_CONFIG.judgment.jev.model;
+  const apiKeyEnv = jev.apiKeyEnv ?? DEFAULT_CONFIG.judgment.jev.apiKeyEnv;
+  if (typeof model !== "string" || !model.trim()) {
+    throw new Error("judgment.jev.model must be a non-empty string");
+  }
+  if (typeof apiKeyEnv !== "string" || !apiKeyEnv.trim()) {
+    throw new Error("judgment.jev.apiKeyEnv must be a non-empty environment variable name");
+  }
+
+  return {
+    default: defaultBackend.trim(),
+    jev: {
+      enabled: jev.enabled === true,
+      model: model.trim(),
+      apiKeyEnv: apiKeyEnv.trim(),
+    },
   };
 }
 
@@ -72,3 +128,38 @@ export async function setModelToolEnabled(configPath: string, enabled: boolean):
   await writeFile(configPath, `${JSON.stringify({ ...existing, modelToolEnabled: enabled }, null, 2)}\n`, "utf8");
   return loadConfig(configPath);
 }
+
+export interface JudgeConfigPatch {
+  /** Default backend name ("llm" or "jev"). */
+  default?: string;
+  /** Partial update of the Jev backend settings. */
+  jev?: Partial<JevJudgeConfig>;
+}
+
+/** Merge a judgment patch into the workspace config, preserving every other field. */
+export async function setJudgeConfig(
+  configPath: string,
+  patch: JudgeConfigPatch,
+): Promise<DeepClauseConfig> {
+  let existing: Record<string, unknown> = {};
+  try {
+    const parsed: unknown = JSON.parse(await readFile(configPath, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) existing = parsed as Record<string, unknown>;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw new Error(`Invalid DeepClause config: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  const record = (value: unknown): Record<string, unknown> =>
+    value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+
+  const nextJudgment = {
+    ...record(existing.judgment),
+    ...(patch.default !== undefined ? { default: patch.default } : {}),
+    jev: { ...record(record(existing.judgment).jev), ...(patch.jev ?? {}) },
+  };
+
+  await writeFile(configPath, `${JSON.stringify({ ...existing, judgment: nextJudgment }, null, 2)}\n`, "utf8");
+  return loadConfig(configPath);
+}

package/src/diagram/viewer.ts

@@ -108,6 +108,17 @@ export async function buildViewer(options: BuildViewerOptions): Promise<ViewerBu
   return { viewerPath, diagramsDir: diagrams, entries };
 }
 
+export async function buildEntriesViewer(options: {
+  cwd: string;
+  templateText: string;
+  vendorAssetPath: string;
+  entries: DiagramEntry[];
+}): Promise<ViewerBuildResult> {
+  const { diagrams, vendorFile } = await ensureDiagramDir(options.cwd, options.vendorAssetPath);
+  const viewerPath = await renderViewer(diagrams, options.entries, options.templateText, vendorFile);
+  return { viewerPath, diagramsDir: diagrams, entries: options.entries };
+}
+
 export async function writeSidecar(diagramsDir: string, name: string, grade: DiagramGrade, code: string): Promise<string> {
   const file = path.join(diagramsDir, `${name}.${grade}.mmd`);
   await writeFile(file, code.endsWith("\n") ? code : `${code}\n`, "utf8");