@dpeek/codeless 0.1.0

package/src/metrics.ts

@@ -0,0 +1,155 @@
+import {
+  existsSync,
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+export type Metric = {
+  stream: string;
+  change: string;
+  dispatchedAt?: string;
+  landedAt?: string;
+  landedCommit?: string;
+};
+
+function metricPath(workspaceRoot: string, stream: string, change: string): string {
+  return join(workspaceRoot, "metrics", stream, `${change}.json`);
+}
+
+function readMetric(path: string): Metric {
+  const value: unknown = JSON.parse(readFileSync(path, "utf8"));
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error(`${path} is not a metric record`);
+  const metric = value as Record<string, unknown>;
+  if (
+    typeof metric["stream"] !== "string" ||
+    typeof metric["change"] !== "string" ||
+    (metric["dispatchedAt"] !== undefined && typeof metric["dispatchedAt"] !== "string") ||
+    (metric["landedAt"] !== undefined && typeof metric["landedAt"] !== "string") ||
+    (metric["landedCommit"] !== undefined && typeof metric["landedCommit"] !== "string")
+  )
+    throw new Error(`${path} is not a metric record`);
+  return metric as Metric;
+}
+
+function writeMetric(path: string, metric: Metric): void {
+  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(metric)}\n`, { flag: "wx" });
+    renameSync(temporary, path);
+  } finally {
+    if (existsSync(temporary)) unlinkSync(temporary);
+  }
+}
+
+export function recordDispatch(workspaceRoot: string, stream: string, change: string): void {
+  const path = metricPath(workspaceRoot, stream, change);
+  if (existsSync(path)) {
+    const metric = readMetric(path);
+    if (metric.stream !== stream || metric.change !== change)
+      throw new Error(`${path} does not match ${stream} change ${change}`);
+    return;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}`;
+  writeFileSync(
+    temporary,
+    `${JSON.stringify({ stream, change, dispatchedAt: new Date().toISOString() })}\n`,
+    { flag: "wx" },
+  );
+  try {
+    linkSync(temporary, path);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+  } finally {
+    unlinkSync(temporary);
+  }
+  readMetric(path);
+}
+
+export function recordLanding(
+  workspaceRoot: string,
+  stream: string,
+  change: string,
+  commit: string,
+): void {
+  const path = metricPath(workspaceRoot, stream, change);
+  if (!existsSync(path)) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeMetric(path, { stream, change, landedAt: new Date().toISOString(), landedCommit: commit });
+    return;
+  }
+  const metric = readMetric(path);
+  if (metric.stream !== stream || metric.change !== change)
+    throw new Error(`${path} does not match ${stream} change ${change}`);
+  if (metric.landedAt !== undefined) return;
+  writeMetric(path, { ...metric, landedAt: new Date().toISOString(), landedCommit: commit });
+}
+
+function formatElapsed(milliseconds: number): string {
+  const seconds = Math.floor(milliseconds / 1000);
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  return hours > 0
+    ? `${hours}h ${String(minutes).padStart(2, "0")}m`
+    : `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`;
+}
+
+export function metricReport(workspaceRoot: string): string[] {
+  const root = join(workspaceRoot, "metrics");
+  const byStream = new Map<string, Metric[]>();
+  if (existsSync(root)) {
+    for (const stream of readdirSync(root).sort()) {
+      const directory = join(root, stream);
+      if (!/^[a-z][a-z0-9-]{0,23}$/.test(stream) || !existsSync(directory)) continue;
+      const records = readdirSync(directory)
+        .filter((file) => /^\d{3}\.json$/.test(file))
+        .sort()
+        .map((file) => readMetric(join(directory, file)));
+      if (records.length > 0) byStream.set(stream, records);
+    }
+  }
+  const summary = (records: Metric[]) => {
+    const landed = records.filter((record) => record.landedAt !== undefined);
+    const elapsed = landed
+      .map((record) => {
+        const start = record.dispatchedAt === undefined ? NaN : Date.parse(record.dispatchedAt);
+        const end = Date.parse(record.landedAt!);
+        return Number.isFinite(start) && Number.isFinite(end) && end >= start
+          ? end - start
+          : undefined;
+      })
+      .filter((value): value is number => value !== undefined);
+    const unavailable = landed.length - elapsed.length;
+    return {
+      landed: landed.length,
+      unlanded: records.length - landed.length,
+      coverage: `${elapsed.length} measured, ${unavailable} unavailable`,
+      total:
+        elapsed.length === 0 ? "unavailable" : formatElapsed(elapsed.reduce((a, b) => a + b, 0)),
+      average:
+        elapsed.length === 0
+          ? "unavailable"
+          : formatElapsed(elapsed.reduce((a, b) => a + b, 0) / elapsed.length),
+    };
+  };
+  const row = (name: string, records: Metric[]) => {
+    const value = summary(records);
+    return `${name}\t${value.landed}\t${value.unlanded}\t${value.coverage}\t${value.total}\t${value.average}`;
+  };
+  const rows = [...byStream.entries()].map(([stream, records]) => ({ stream, records }));
+  return [
+    "Stream\tLanded\tNot landed\tElapsed coverage\tDispatch-to-land wall clock total\tAverage",
+    ...rows.map(({ stream, records }) => row(stream, records)),
+    row(
+      "Project total",
+      rows.flatMap(({ records }) => records),
+    ),
+  ];
+}

package/src/pi.ts

@@ -0,0 +1,174 @@
+import type { RoleSelection } from "./project.ts";
+
+type Role = "planner" | "implementer";
+type JsonObject = Record<string, unknown>;
+
+const validationTimeoutMs = 30_000;
+
+function object(value: unknown, label: string): JsonObject {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`Pi RPC response omitted ${label}`);
+  }
+  return value as JsonObject;
+}
+
+function strings(value: unknown, label: string): string[] {
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
+    throw new Error(`Pi RPC response omitted ${label}`);
+  }
+  return value;
+}
+
+export function roleSelectionReference(selection: RoleSelection): string {
+  return `${selection.provider}/${selection.model}`;
+}
+
+export function roleSelectionSummary(role: Role, selection: RoleSelection): string {
+  const label = role === "planner" ? "Planner" : "Implementer";
+  return `${label}: ${roleSelectionReference(selection)} (thinking: ${selection.thinking})`;
+}
+
+export function roleSelectionArguments(selection: RoleSelection): string[] {
+  return ["--model", roleSelectionReference(selection), "--thinking", selection.thinking];
+}
+
+export async function validateRoleSelection(
+  role: Role,
+  selection: RoleSelection,
+  worktree: string,
+  extension?: string,
+): Promise<void> {
+  const reference = roleSelectionReference(selection);
+  const label = role === "planner" ? "Planner" : "Implementer";
+  const child = Bun.spawn(
+    [
+      "pi",
+      "--mode",
+      "rpc",
+      "--no-session",
+      "--approve",
+      ...(extension === undefined ? [] : ["--extension", extension]),
+    ],
+    {
+      cwd: worktree,
+      env: process.env,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  const stderr = new Response(child.stderr).text();
+  const reader = child.stdout.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let requestNumber = 0;
+  const timeout = setTimeout(() => child.kill(), validationTimeoutMs);
+
+  async function line(): Promise<string> {
+    while (true) {
+      const newline = buffer.indexOf("\n");
+      if (newline >= 0) {
+        const value = buffer.slice(0, newline).replace(/\r$/, "");
+        buffer = buffer.slice(newline + 1);
+        return value;
+      }
+      const chunk = await reader.read();
+      if (chunk.done) {
+        buffer += decoder.decode();
+        if (buffer.length > 0) {
+          const value = buffer.replace(/\r$/, "");
+          buffer = "";
+          return value;
+        }
+        const diagnostic = (await stderr).trim();
+        throw new Error(
+          diagnostic || `Pi RPC exited with code ${await child.exited} before responding`,
+        );
+      }
+      buffer += decoder.decode(chunk.value, { stream: true });
+    }
+  }
+
+  async function request(type: string, fields: JsonObject = {}): Promise<unknown> {
+    const id = `streams-${++requestNumber}`;
+    await child.stdin.write(`${JSON.stringify({ id, type, ...fields })}\n`);
+    await child.stdin.flush();
+    while (true) {
+      const output = await line();
+      let response: JsonObject;
+      try {
+        response = object(JSON.parse(output), "object");
+      } catch (error) {
+        throw new Error(
+          `Pi RPC returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+      if (response["type"] !== "response" || response["id"] !== id) continue;
+      if (response["success"] !== true) {
+        throw new Error(
+          typeof response["error"] === "string"
+            ? response["error"]
+            : `Pi RPC ${type} request failed`,
+        );
+      }
+      return response["data"];
+    }
+  }
+
+  try {
+    const available = object(await request("get_available_models"), "data")["models"];
+    if (!Array.isArray(available)) throw new Error("Pi RPC response omitted data.models");
+    const model = available
+      .map((value, index) => object(value, `data.models[${index}]`))
+      .find((value) => value["provider"] === selection.provider && value["id"] === selection.model);
+    if (model === undefined) {
+      throw new Error(
+        `${reference} is not available; check the exact provider/model and Pi authentication`,
+      );
+    }
+
+    await request("set_model", { provider: selection.provider, modelId: selection.model });
+    const levels = strings(
+      object(await request("get_available_thinking_levels"), "data")["levels"],
+      "data.levels",
+    );
+    if (!levels.includes(selection.thinking)) {
+      throw new Error(
+        `${reference} does not support thinking level ${selection.thinking}; supported levels: ${levels.join(", ")}`,
+      );
+    }
+
+    await request("set_thinking_level", { level: selection.thinking });
+    if (extension !== undefined) {
+      const commands = object(await request("get_commands"), "data")["commands"];
+      if (
+        !Array.isArray(commands) ||
+        !commands.some((command) => object(command, "command")["name"] === "streams-activate")
+      ) {
+        throw new Error("the Codeless planner extension did not register streams-activate");
+      }
+    }
+
+    const state = object(await request("get_state"), "data");
+    const effectiveModel = object(state["model"], "data.model");
+    if (
+      effectiveModel["provider"] !== selection.provider ||
+      effectiveModel["id"] !== selection.model ||
+      state["thinkingLevel"] !== selection.thinking
+    ) {
+      const effectiveReference = `${String(effectiveModel["provider"])}/${String(effectiveModel["id"])}`;
+      throw new Error(
+        `Pi applied ${effectiveReference} at ${String(state["thinkingLevel"])} instead of the requested selection`,
+      );
+    }
+  } catch (error) {
+    throw new Error(
+      `${label} requested ${reference} at thinking level ${selection.thinking}, but validation failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  } finally {
+    clearTimeout(timeout);
+    await child.stdin.end();
+    await child.exited;
+    reader.releaseLock();
+  }
+}

package/src/project.ts

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+import { readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+
+export const ThinkingLevel = Schema.Literals([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+]);
+
+export const RoleSelection = Schema.Struct({
+  provider: Schema.NonEmptyString,
+  model: Schema.NonEmptyString,
+  thinking: ThinkingLevel,
+});
+
+export type RoleSelection = typeof RoleSelection.Type;
+
+const Project = Schema.Struct({
+  integrationBranch: Schema.NonEmptyString,
+  directions: Schema.NonEmptyString,
+  prompts: Schema.NonEmptyString,
+  install: Schema.NonEmptyArray(Schema.String),
+  check: Schema.NonEmptyArray(Schema.String),
+  planner: RoleSelection,
+  implementer: RoleSelection,
+});
+
+export function readProject(worktree: string) {
+  const path = join(worktree, ".codeless/config.json");
+  try {
+    const project = Schema.decodeUnknownSync(Project, { onExcessProperty: "error" })(
+      JSON.parse(readFileSync(path, "utf8")),
+    );
+    for (const field of ["directions", "prompts"] as const) {
+      const value = project[field];
+      const local = relative(worktree, resolve(worktree, value));
+      if (isAbsolute(value) || local === ".." || local.startsWith("../")) {
+        throw new Error(`${field} must be a path inside the project`);
+      }
+    }
+    for (const field of ["install", "check"] as const) {
+      if (!project[field][0].trim()) throw new Error(`${field} needs an executable`);
+    }
+    return project;
+  } catch (error) {
+    throw new Error(
+      `Invalid Codeless project configuration at ${path}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}