deepclause-pi 0.2.0 → 0.4.0

package/README.md

@@ -131,6 +131,19 @@ The resulting `.dml` file is the plan. Steps use one of two executors:
 
 For each pi step, only the exact tools named in the committed plan are temporarily active. They must still be installed and active when execution begins; existing tool policies, UI, and approvals remain authoritative. DeepClause control tools cannot be requested recursively. The prior active-tool set is restored after success, failure, or cancellation.
 
+## deepclause-pi speckit
+
+Spec-driven changes, built on the same runtime: behaviour specs in plain Markdown, reviewable change deltas, and an executable `tasks.dml` that pi runs with deterministic validation, per-task verification, rollback and resume.
+
+```text
+/dc-plan <request> --change=<slug>   propose
+/dc-check <slug>                     validate (0 tokens)
+/dc-apply <slug>                     execute, verify, retry, resume
+/dc-archive <slug>                   merge into specs/
+```
+
+See the [deepclause-pi speckit guide](docs/SPECKIT.md) for the getting-started walkthrough and reference.
+
 ## Diagrams
 
 Ask pi for a diagram of any DML file in plain language:

package/dist/config.d.ts

@@ -1,4 +1,17 @@
 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;
@@ -7,7 +20,16 @@ export interface DeepClauseConfig {
     maxTokens: number;
     verbose: boolean;
     modelToolEnabled: boolean;
+    judgment: JudgmentConfig;
 }
 export declare const DEFAULT_CONFIG: DeepClauseConfig;
 export declare function loadConfig(path: string): Promise<DeepClauseConfig>;
 export declare function setModelToolEnabled(configPath: string, enabled: boolean): Promise<DeepClauseConfig>;
+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 declare function setJudgeConfig(configPath: string, patch: JudgeConfigPatch): Promise<DeepClauseConfig>;

package/dist/config.js

@@ -7,6 +7,10 @@ export const DEFAULT_CONFIG = {
     maxTokens: 16_384,
     verbose: false,
     modelToolEnabled: false,
+    judgment: {
+        default: "llm",
+        jev: { enabled: false, model: "jev-latest", apiKeyEnv: "TYPESAFE_API_KEY" },
+    },
 };
 const isContextMode = (value) => value === "turn" || value === "branch" || value === "isolated";
 export async function loadConfig(path) {
@@ -40,6 +44,40 @@ export async function loadConfig(path) {
         maxTokens: positiveInteger("maxTokens", DEFAULT_CONFIG.maxTokens),
         verbose: config.verbose === true,
         modelToolEnabled: config.modelToolEnabled === true,
+        judgment: parseJudgmentConfig(config.judgment),
+    };
+}
+function parseJudgmentConfig(value) {
+    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;
+    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;
+    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(),
+        },
     };
 }
 export async function setModelToolEnabled(configPath, enabled) {
@@ -57,3 +95,25 @@ export async function setModelToolEnabled(configPath, enabled) {
     await writeFile(configPath, `${JSON.stringify({ ...existing, modelToolEnabled: enabled }, null, 2)}\n`, "utf8");
     return loadConfig(configPath);
 }
+/** Merge a judgment patch into the workspace config, preserving every other field. */
+export async function setJudgeConfig(configPath, patch) {
+    let existing = {};
+    try {
+        const parsed = JSON.parse(await readFile(configPath, "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+            existing = parsed;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw new Error(`Invalid DeepClause config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    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/dist/diagram/viewer.d.ts

@@ -25,6 +25,12 @@ export interface BuildViewerOptions {
  * sidecars, and write the self-contained viewer plus per-skill Markdown.
  */
 export declare function buildViewer(options: BuildViewerOptions): Promise<ViewerBuildResult>;
+export declare function buildEntriesViewer(options: {
+    cwd: string;
+    templateText: string;
+    vendorAssetPath: string;
+    entries: DiagramEntry[];
+}): Promise<ViewerBuildResult>;
 export declare function writeSidecar(diagramsDir: string, name: string, grade: DiagramGrade, code: string): Promise<string>;
 /** Open the viewer at a specific diagram and view using a fixed, OS-native argv. */
 export declare function openViewerInBrowser(pi: Pick<ExtensionAPI, "exec">, viewerPath: string, name: string, view: string): Promise<boolean>;

package/dist/diagram/viewer.js

@@ -71,6 +71,11 @@ export async function buildViewer(options) {
     const viewerPath = await renderViewer(diagrams, entries, options.templateText, vendorFile);
     return { viewerPath, diagramsDir: diagrams, entries };
 }
+export async function buildEntriesViewer(options) {
+    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, name, grade, code) {
     const file = path.join(diagramsDir, `${name}.${grade}.mmd`);
     await writeFile(file, code.endsWith("\n") ? code : `${code}\n`, "utf8");

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type ContextMode } from "./config.js";
 export interface ParsedRun {
     target: string;
@@ -6,14 +6,22 @@ export interface ParsedRun {
     contextMode?: ContextMode;
     verbose: boolean;
     debug: boolean;
+    judge?: string;
 }
 interface ParsedPlan {
     request: string;
     name?: string;
+    change?: string;
+    update?: boolean;
     debug: boolean;
 }
 export declare function splitArguments(input: string): string[];
 export declare function parseRun(input: string): ParsedRun;
 export declare function parsePlan(input: string): ParsedPlan;
+/**
+ * After a step that leaves the tree dirty, offer to commit it (or remind the user).
+ * A clean tree is what lets the next /dc-apply take a rollback snapshot.
+ */
+export declare function offerCommit(pi: ExtensionAPI, ctx: ExtensionContext, action: string, change: string): Promise<void>;
 export default function deepClauseExtension(pi: ExtensionAPI): void;
 export {};