pi-rlm 0.1.0

package/src/types.ts

@@ -0,0 +1,80 @@
+export type RlmBackend = "sdk" | "cli" | "tmux";
+export type RlmMode = "auto" | "solve" | "decompose";
+export type RlmOp = "start" | "status" | "wait" | "cancel";
+export type RlmToolsProfile = "coding" | "read-only";
+
+export type RunStatus = "running" | "completed" | "failed" | "cancelled";
+export type NodeStatus = "running" | "completed" | "failed" | "cancelled";
+
+export interface StartRunInput {
+  task: string;
+  backend: RlmBackend;
+  mode: RlmMode;
+  async: boolean;
+  model?: string;
+  cwd: string;
+  toolsProfile: RlmToolsProfile;
+  maxDepth: number;
+  maxNodes: number;
+  maxBranching: number;
+  concurrency: number;
+  timeoutMs: number;
+}
+
+export interface RlmNode {
+  id: string;
+  depth: number;
+  task: string;
+  status: NodeStatus;
+  decision?: {
+    action: "solve" | "decompose";
+    reason: string;
+    raw?: string;
+  };
+  startedAt: number;
+  finishedAt?: number;
+  result?: string;
+  error?: string;
+  children: RlmNode[];
+}
+
+export interface RunArtifacts {
+  dir: string;
+  eventsPath: string;
+  treePath: string;
+  outputPath: string;
+}
+
+export interface RunStats {
+  nodesVisited: number;
+  maxDepthSeen: number;
+  durationMs: number;
+}
+
+export interface RlmRunResult {
+  runId: string;
+  backend: RlmBackend;
+  final: string;
+  root: RlmNode;
+  artifacts: RunArtifacts;
+  stats: RunStats;
+}
+
+export interface RunRecord {
+  id: string;
+  input: StartRunInput;
+  status: RunStatus;
+  createdAt: number;
+  startedAt: number;
+  finishedAt?: number;
+  error?: string;
+  controller: AbortController;
+  promise: Promise<RlmRunResult>;
+  result?: RlmRunResult;
+}
+
+export interface PlannerDecision {
+  action: "solve" | "decompose";
+  reason: string;
+  subtasks?: string[];
+}

package/src/utils.ts

@@ -0,0 +1,128 @@
+import crypto from "node:crypto";
+
+const thinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
+
+export function createRunId(): string {
+  return crypto.randomUUID().slice(0, 8);
+}
+
+export function truncateText(
+  text: string,
+  maxChars: number
+): { text: string; truncated: boolean; originalChars: number } {
+  if (text.length <= maxChars) {
+    return { text, truncated: false, originalChars: text.length };
+  }
+
+  return {
+    text: `${text.slice(0, maxChars)}\n\n[truncated ${text.length - maxChars} chars]`,
+    truncated: true,
+    originalChars: text.length
+  };
+}
+
+export function normalizeTask(task: string): string {
+  return task.replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+export function shortTask(task: string, max = 80): string {
+  if (task.length <= max) return task;
+  return `${task.slice(0, max - 3)}...`;
+}
+
+export function extractFirstJsonObject(text: string): string | undefined {
+  const firstBrace = text.indexOf("{");
+  if (firstBrace === -1) return undefined;
+
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let i = firstBrace; i < text.length; i += 1) {
+    const ch = text[i];
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+
+    if (ch === "{") depth += 1;
+    if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return text.slice(firstBrace, i + 1);
+      }
+    }
+  }
+
+  return undefined;
+}
+
+export function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
+export function toErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export function parseModelPattern(model: string | undefined): {
+  provider: string;
+  id: string;
+  thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+} | undefined {
+  if (!model) return undefined;
+
+  const trimmed = model.trim();
+  if (!trimmed.includes("/")) return undefined;
+
+  const lastColon = trimmed.lastIndexOf(":");
+  const hasThinkingSuffix =
+    lastColon > -1 &&
+    thinkingLevels.has(trimmed.slice(lastColon + 1)) &&
+    !trimmed.slice(lastColon + 1).includes("/");
+
+  const modelPart = hasThinkingSuffix ? trimmed.slice(0, lastColon) : trimmed;
+  const thinkingPart = hasThinkingSuffix ? trimmed.slice(lastColon + 1) : undefined;
+
+  const slashIdx = modelPart.indexOf("/");
+  const provider = modelPart.slice(0, slashIdx).trim().toLowerCase();
+  const id = modelPart.slice(slashIdx + 1).trim();
+
+  if (!provider || !id) return undefined;
+
+  return {
+    provider,
+    id,
+    thinkingLevel: thinkingPart as
+      | "off"
+      | "minimal"
+      | "low"
+      | "medium"
+      | "high"
+      | "xhigh"
+      | undefined
+  };
+}