@llblab/pi-kit 0.1.0

package/node_modules/@llblab/pi-actors/dist/lib/automatic-review-runtime.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Automatic recipe-review runtime composition.
+ * Zones: session-bound review schedulers, silent reviewer launch adapters, review controls
+ * Owns automatic-review lifecycle wiring without owning review decisions or filesystem transactions.
+ */
+import type * as Pi from "./pi.ts";
+import * as RecipesReferences from "./recipes-references.ts";
+export interface AutomaticReviewRuntime {
+    close(): void;
+    handleControl(action: string, input: unknown): Record<string, unknown>;
+    schedule(): void;
+    start(ctx: Pi.ExtensionContext): void;
+}
+export interface AutomaticReviewRuntimeDeps {
+    getActiveContext(): Pi.ExtensionContext | undefined;
+    getRunOwnerId(ctx: Pi.ExtensionContext): string;
+    getThinkingLevel(): unknown;
+}
+export declare const PACKAGE_RECIPE_MEMORY_CONTEXT: RecipesReferences.ActiveSkillRecipeContext;
+export declare function createAutomaticReviewRuntime(deps: AutomaticReviewRuntimeDeps): AutomaticReviewRuntime;

package/node_modules/@llblab/pi-actors/dist/lib/automatic-review-runtime.js

@@ -0,0 +1,103 @@
+/**
+ * Automatic recipe-review runtime composition.
+ * Zones: session-bound review schedulers, silent reviewer launch adapters, review controls
+ * Owns automatic-review lifecycle wiring without owning review decisions or filesystem transactions.
+ */
+import { fileURLToPath } from "node:url";
+import * as AsyncRuns from "./async-runs.js";
+import * as DraftSleep from "./draft-sleep.js";
+import * as ModelContext from "./model-context.js";
+import * as Paths from "./paths.js";
+import * as RecipesReferences from "./recipes-references.js";
+import * as ReviewControl from "./review-control.js";
+import * as ToolReviewScheduler from "./tool-review-scheduler.js";
+export const PACKAGE_RECIPE_MEMORY_CONTEXT = RecipesReferences.createActiveSkillRecipeContext([
+    {
+        name: "recipe-memory",
+        filePath: fileURLToPath(new URL("../skills/recipe-memory/SKILL.md", import.meta.url)),
+    },
+]);
+export function createAutomaticReviewRuntime(deps) {
+    let draftScheduler;
+    let toolScheduler;
+    const close = () => {
+        draftScheduler?.close();
+        draftScheduler = undefined;
+        toolScheduler?.close();
+        toolScheduler = undefined;
+    };
+    const hasActiveActors = () => AsyncRuns.listRuns(Paths.EXTENSION_RUNTIME_PATHS.runStateRoot, "running").length > 0;
+    const policyValues = (ctx) => ModelContext.withCurrentModelValues({}, {
+        ...ctx,
+        getThinkingLevel: deps.getThinkingLevel,
+    });
+    return {
+        close,
+        handleControl(action, input) {
+            if (action !== "review.retry" && action !== "review.reset") {
+                throw new Error("runtime accepts review.retry or review.reset Controls.");
+            }
+            if (action === "review.retry" && !Paths.isAutomaticRecipeReviewEnabled()) {
+                throw new Error("Automatic recipe review is disabled by PI_ACTORS_AUTOMATIC_REVIEW.");
+            }
+            return ReviewControl.controlAutomaticReview(action, ReviewControl.parseAutomaticReviewScope(input), {
+                scheduleDraft: () => draftScheduler?.schedule(),
+                scheduleTool: () => toolScheduler?.schedule(),
+            });
+        },
+        schedule() {
+            draftScheduler?.schedule();
+            toolScheduler?.schedule();
+        },
+        start(ctx) {
+            close();
+            if (!Paths.isAutomaticRecipeReviewEnabled())
+                return;
+            ToolReviewScheduler.applyApprovedToolReviewAtSessionBoundary({
+                recipeRoot: Paths.getRecipeRoot(),
+            });
+            draftScheduler = DraftSleep.createDraftSleepScheduler({
+                hasActiveActors,
+                launch: (batch) => {
+                    if (deps.getActiveContext() !== ctx) {
+                        throw new Error("Draft review session changed before launch.");
+                    }
+                    return AsyncRuns.startRun({
+                        file: "recipe-memory/draft-review",
+                        launch_source: "tool",
+                        notification_policy: "silent",
+                        ownerId: deps.getRunOwnerId(ctx),
+                        policy_values: policyValues(ctx),
+                        run_id: DraftSleep.draftSleepRunId(batch.batchId),
+                        values: { input_path: batch.reviewerInputPath },
+                    }, ctx.cwd, { skillContext: PACKAGE_RECIPE_MEMORY_CONTEXT });
+                },
+                process: (state) => DraftSleep.processDraftSleepReview(state, {
+                    getRunStatus: AsyncRuns.getRunStatus,
+                    recipeRoot: Paths.getRecipeRoot(),
+                }),
+            });
+            toolScheduler = ToolReviewScheduler.createToolReviewScheduler({
+                hasActiveActors,
+                launch: (batch) => {
+                    if (deps.getActiveContext() !== ctx) {
+                        throw new Error("Tool review session changed before launch.");
+                    }
+                    return AsyncRuns.startRun({
+                        file: "recipe-memory/tool-review",
+                        launch_source: "tool",
+                        notification_policy: "silent",
+                        ownerId: deps.getRunOwnerId(ctx),
+                        policy_values: policyValues(ctx),
+                        run_id: ToolReviewScheduler.toolReviewRunId(batch.reviewId),
+                        values: { input_path: batch.reviewerInputPath },
+                    }, ctx.cwd, { skillContext: PACKAGE_RECIPE_MEMORY_CONTEXT });
+                },
+                process: (state) => ToolReviewScheduler.processToolReviewResult(state, {
+                    getRunStatus: AsyncRuns.getRunStatus,
+                    recipeRoot: Paths.getRecipeRoot(),
+                }),
+            });
+        },
+    };
+}

package/node_modules/@llblab/pi-actors/dist/lib/command-templates.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Command-template execution standard.
+ * Zones: shell-free command parsing, placeholder expansion, local process execution, composition semantics
+ * Owns portable command-template parsing, expansion, risk checks, retries, timeouts, and direct execution.
+ */
+export type CommandTemplateFailureScope = "continue" | "branch" | "root";
+export interface CommandTemplateActorRecipeContext {
+    alias?: string;
+    file?: string;
+    name?: string;
+    path?: string;
+    role?: string;
+}
+export interface CommandTemplateObjectConfig {
+    actorRecipeContext?: CommandTemplateActorRecipeContext;
+    label?: string;
+    parallel?: boolean;
+    concurrency?: number | string;
+    min_successful?: number | string;
+    when?: boolean | string;
+    template?: CommandTemplateValue;
+    args?: string[];
+    defaults?: Record<string, unknown>;
+    timeout?: number | string;
+    delay?: number | string;
+    accept_output?: "review_evidence";
+    output?: string;
+    retry?: number | string;
+    failure?: CommandTemplateFailureScope;
+    recover?: CommandTemplateValue;
+    repeat?: number | string;
+}
+export type CommandTemplateValue = string | CommandTemplateConfig[] | CommandTemplateObjectConfig;
+export type CommandTemplateConfig = string | CommandTemplateObjectConfig;
+export interface CommandTemplateLeafConfig extends CommandTemplateObjectConfig {
+    template: string;
+}
+export interface CommandTemplateInvocation {
+    command: string;
+    args: string[];
+}
+export interface CommandTemplateExecOptions {
+    cwd?: string;
+    timeout?: number;
+    signal?: AbortSignal;
+    stdin?: string;
+    killGrace?: number;
+    retry?: number;
+    captureDir?: string;
+    captureLimitBytes?: number;
+}
+export interface CommandTemplateExecResult {
+    stdout: string;
+    stderr: string;
+    code: number;
+    killed: boolean;
+    stdoutBytes?: number;
+    stderrBytes?: number;
+    stdoutFile?: string;
+    stderrFile?: string;
+    stdoutTruncated?: boolean;
+    stderrTruncated?: boolean;
+}
+export type CommandTemplateRiskLabel = "risk.shell" | "risk.eval" | "risk.broad_fs_write" | "risk.destructive_fs" | "risk.network" | "risk.external_side_effect" | "risk.long_running" | "risk.platform_specific" | "risk.secret_touching";
+export type CommandTemplateExecCommand = (command: string, args: string[], options?: CommandTemplateExecOptions) => Promise<CommandTemplateExecResult>;
+export declare function normalizeCommandTemplateConfig(config: CommandTemplateConfig): CommandTemplateObjectConfig;
+export declare function resolveInheritedDefaultReferences(ownDefaults: Record<string, unknown> | undefined, inheritedDefaults: Record<string, unknown> | undefined, runtimeValues?: Record<string, unknown>): Record<string, unknown> | undefined;
+export declare function resolveCommandTemplateRepeat(value: number | string | undefined, values?: Record<string, unknown>): number | undefined;
+export declare function isCommandTemplateRepeatPlaceholder(name: string): boolean;
+export declare function getCommandTemplateRepeatDefaults(index: number, repeat: number): Record<string, string>;
+export declare function expandCommandTemplateConfigs(config: CommandTemplateConfig, inherited?: Pick<CommandTemplateObjectConfig, "args" | "defaults">): CommandTemplateLeafConfig[];
+export declare function getCommandTemplateWarnings(config: CommandTemplateConfig): string[];
+export declare function getCommandTemplateRiskLabels(config: CommandTemplateConfig): CommandTemplateRiskLabel[];
+export declare function getCommandTemplateDefaults(config: CommandTemplateConfig | undefined): Record<string, string>;
+export declare function splitCommandTemplate(input: string): string[];
+export declare function expandCommandTemplateExecutable(command: string, cwd: string): string;
+export type CommandTemplateExecutableResolver = (name: string) => string | undefined;
+export declare function resolveCommandTemplateScriptInvocation(invocation: CommandTemplateInvocation, resolveExecutable?: CommandTemplateExecutableResolver): CommandTemplateInvocation;
+export declare function shouldRunCommandTemplateNode(value: boolean | string | undefined, values: Record<string, unknown>): boolean;
+export declare function substituteCommandTemplateToken(token: string, values: Record<string, unknown>, missingLabel?: string, depth?: number): string;
+export declare function execCommandTemplate(command: string, args: string[], options?: CommandTemplateExecOptions): Promise<CommandTemplateExecResult>;
+export declare function buildCommandTemplateInvocation(config: CommandTemplateConfig, values: Record<string, unknown>, cwd: string, options?: {
+    emptyMessage?: string;
+    missingLabel?: string;
+}): CommandTemplateInvocation;