@anhlp/alp-runtime 0.0.0-stage → 0.0.1-beta.4

package/dist/board.js

@@ -0,0 +1,69 @@
+// packages/runtime/src/board.ts
+import path from "node:path";
+import { realpathSync } from "node:fs";
+var PIN_KINDS = ["claim", "decision", "finding"];
+var PIN_BODY_CHARS = 2e3;
+var PIN_PATHS = 50;
+var BOARD_KEEP = 200;
+var DIGEST_CHARS = 3e3;
+function canonicalPath(file) {
+  try {
+    return realpathSync(file);
+  } catch {
+    const parent = path.dirname(file);
+    return parent === file ? file : path.join(canonicalPath(parent), path.basename(file));
+  }
+}
+var containsPath = (outer, inner) => {
+  const relative = path.relative(outer, inner);
+  return !relative || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+};
+function normalizePaths(paths, project, roots = [project]) {
+  if (!Array.isArray(paths) || !paths.length || paths.length > PIN_PATHS) return `paths must list 1 to ${PIN_PATHS} files or directories`;
+  const normalized = [];
+  for (const entry of paths) {
+    if (typeof entry !== "string" || !entry.trim()) return "paths must be nonempty strings";
+    const absolute = canonicalPath(path.resolve(project, entry.trim()));
+    if (!roots.some((root) => containsPath(canonicalPath(root), absolute))) return `${entry} is outside the project or declared write root`;
+    const relative = path.relative(canonicalPath(project), absolute).split(path.sep).join("/");
+    normalized.push(relative === "" ? "." : relative === ".." || relative.startsWith("../") || path.isAbsolute(relative) ? absolute.split(path.sep).join("/") : relative);
+  }
+  return [...new Set(normalized)];
+}
+var contains = (outer, inner) => path.isAbsolute(outer) === path.isAbsolute(inner) && (outer === "." || inner === outer || inner.startsWith(outer.endsWith("/") ? outer : `${outer}/`));
+function overlapping(a, b) {
+  return a.filter((left) => b.some((right) => contains(left, right) || contains(right, left)));
+}
+var live = (pin) => !pin.released;
+function renderPin(pin) {
+  const where = pin.paths?.length ? ` [${pin.paths.join(", ")}]` : "";
+  return `${pin.kind} ${pin.id} by ${pin.agent}${pin.task ? ` for task ${pin.task}` : ""}${where}: ${pin.body}`;
+}
+function renderBoard(pins, limit = DIGEST_CHARS) {
+  const claims = pins.filter((pin) => pin.kind === "claim" && live(pin));
+  const notes = pins.filter((pin) => pin.kind !== "claim" && live(pin)).reverse();
+  if (!claims.length && !notes.length) return "";
+  const lines = ["Project board (shared by every agent on this project; read more with alp_board):"];
+  let size = lines[0].length;
+  for (const pin of [...claims, ...notes]) {
+    const line = `- ${renderPin(pin)}`;
+    if (size + line.length > limit) {
+      lines.push("- \u2026 more on alp_board");
+      break;
+    }
+    lines.push(line);
+    size += line.length;
+  }
+  return lines.join("\n");
+}
+export {
+  BOARD_KEEP,
+  PIN_BODY_CHARS,
+  PIN_KINDS,
+  PIN_PATHS,
+  live,
+  normalizePaths,
+  overlapping,
+  renderBoard,
+  renderPin
+};

package/dist/catalog.d.ts

@@ -0,0 +1,31 @@
+export declare const DEFAULT_MODEL = "gpt-5.6-sol";
+export declare const DEFAULT_CLAUDE_MODEL = "sonnet";
+export declare const DEFAULT_ANTIGRAVITY_MODEL = "gemini-3.8-flash-high";
+/** Oracle runs on one of these; main may consult both for two opinions. */
+export declare const ORACLE_MODELS: string[];
+export declare const ORACLE_THINKING = "high";
+export declare const modes: {
+    id: string;
+    label: string;
+}[];
+/** Whether a session in `mode` may run with `requested`; a child never exceeds its requester. */
+export declare const withinMode: (requested: string, mode: string) => boolean;
+export declare const writes: (mode: string) => boolean;
+export declare const thinkingOptions: {
+    id: string;
+    label: string;
+}[];
+export declare const models: {
+    defaultThinkingOptionId?: string | undefined;
+    id: string;
+    label: string;
+    description: string;
+    thinkingOptions: {
+        id: string;
+        label: string;
+    }[];
+}[];
+export declare function thinkingOptionsFor(runtime: 'codex' | 'claude' | 'antigravity', nativeModel: string): {
+    id: string;
+    label: string;
+}[];

package/dist/catalog.js

@@ -0,0 +1,38 @@
+// packages/runtime/src/catalog.ts
+import { MODELS } from "@anhlp/alp-core/models";
+var DEFAULT_MODEL = "gpt-5.6-sol";
+var DEFAULT_CLAUDE_MODEL = "sonnet";
+var DEFAULT_ANTIGRAVITY_MODEL = "gemini-3.8-flash-high";
+var ORACLE_MODELS = ["claude:claude-fable-5-1", "codex:gpt-6-astra"];
+var ORACLE_THINKING = "high";
+var modes = [{ id: "read-only", label: "Read only" }, { id: "workspace-write", label: "Workspace write" }, { id: "full-access", label: "Full access" }];
+var modeRank = { "read-only": 0, "workspace-write": 1, "full-access": 2 };
+var withinMode = (requested, mode) => (modeRank[requested] ?? 3) <= (modeRank[mode] ?? -1);
+var writes = (mode) => mode !== "read-only";
+var option = (id) => ({ id, label: id });
+var options = (ids) => ids.map(option);
+var thinkingOptions = options(["none", "off", "low", "medium", "high", "xhigh", "max", "ultra", "ultracode"]);
+var model = (runtime, id, label, description, modelThinkingOptions, defaultThinkingOptionId) => ({
+  id: `${runtime}:${id}`,
+  label: `${runtime === "codex" ? "Codex" : runtime === "claude" ? "Claude Code" : "Antigravity"} \xB7 ${label}`,
+  description,
+  thinkingOptions: modelThinkingOptions,
+  ...defaultThinkingOptionId ? { defaultThinkingOptionId } : {}
+});
+var models = MODELS.map((entry) => model(entry.runtime, entry.id, entry.label, entry.description, options(entry.efforts), entry.effort));
+function thinkingOptionsFor(runtime, nativeModel) {
+  return models.find((candidate) => candidate.id === `${runtime}:${nativeModel}`)?.thinkingOptions ?? thinkingOptions;
+}
+export {
+  DEFAULT_ANTIGRAVITY_MODEL,
+  DEFAULT_CLAUDE_MODEL,
+  DEFAULT_MODEL,
+  ORACLE_MODELS,
+  ORACLE_THINKING,
+  models,
+  modes,
+  thinkingOptions,
+  thinkingOptionsFor,
+  withinMode,
+  writes
+};

package/dist/claude-transport.d.ts

@@ -0,0 +1,202 @@
+import { z } from 'zod';
+export declare const toolShapes: Record<string, Record<string, z.ZodType>>;
+type Listener = (method: string, params: any) => void;
+type RequestHandler = (method: string, params: any) => Promise<unknown>;
+/** The plugin name ALP's skills are loaded under, so Claude Code calls them alp:<name>. */
+export declare const SKILL_PLUGIN = "alp";
+/**
+ * A Claude Code plugin in `directory` holding the given skills, linked to their own
+ * directories so an edit to a skill reaches the next session (ALPD §59).
+ */
+export declare function skillPlugin(directory: string, skills: Array<{
+    name: string;
+    path: string;
+}>): string;
+type PermissionRules = {
+    allow: string[];
+    ask?: string[];
+    deny: string[];
+    beyondMode?: 'refuse' | 'ask';
+    /** The OS sandbox ALP puts Bash in, and the directory it may write besides temp files. */
+    floor?: 'read-only' | 'workspace-write';
+    floorRoot?: string;
+};
+/** Whether Claude Code can sandbox Bash here: Seatbelt on macOS, bubblewrap and socat on Linux. ALP_CLAUDE_SANDBOX=0 turns it off, =1 claims it (tests). */
+export declare function claudeSandboxAvailable(): boolean;
+/** What ALP asks the user for a permission Claude would otherwise not have. */
+/** One turn-input part as Claude's: text, or a data-URL image as a base64 image block. */
+export declare function claudeContent(part: any): {
+    type: string;
+    source: {
+        type: string;
+        media_type: string;
+        data: string;
+    };
+    text?: undefined;
+} | {
+    type: string;
+    text: any;
+    source?: undefined;
+};
+export type PermissionRequest = {
+    tool: string;
+    input: Record<string, unknown>;
+    reason: 'rule' | 'mode';
+    rule?: string;
+};
+export type PermissionAnswer = {
+    allow: boolean;
+    always?: boolean;
+    message?: string;
+};
+/** Claude's permission mode for an ALP mode; full-access skips every permission check. */
+export declare const claudePermissionMode: (sandbox: string) => "default" | "acceptEdits" | "bypassPermissions";
+export declare function claudePermissions(sandbox: string, currentSandbox?: () => string, rules?: PermissionRules | null, ask?: (request: PermissionRequest) => Promise<PermissionAnswer>): {
+    canUseTool: (name: string, input: Record<string, unknown>, context?: {
+        decisionReasonType?: string;
+        suggestions?: unknown;
+    }) => Promise<{
+        behavior: string;
+        message: string;
+    } | {
+        updatedPermissions?: {
+            type: string;
+            rules: {
+                ruleContent?: string | undefined;
+                toolName: string;
+            }[];
+            behavior: string;
+            destination: string;
+        }[] | undefined;
+        behavior: string;
+        updatedInput: Record<string, unknown>;
+        message?: undefined;
+    }>;
+    sandbox?: {
+        filesystem?: {
+            denyWrite: string[];
+        } | undefined;
+        enabled: boolean;
+        autoAllowBashIfSandboxed: boolean;
+        allowUnsandboxedCommands: boolean;
+    } | undefined;
+    settings?: {
+        permissions: {
+            ask: string[];
+        };
+    } | undefined;
+    disallowedTools: string[];
+    allowedTools?: string[] | undefined;
+    tools?: string[] | undefined;
+    permissionMode: string;
+    allowDangerouslySkipPermissions: boolean;
+};
+/** Whether Claude's last rate limit report means requests are refused: rejected, with no overage to fall back on. */
+export declare const claudeLimited: (info?: {
+    status: string;
+    overageStatus?: string;
+}) => boolean;
+/**
+ * A Claude session's main chain, read from its transcript by the Agent SDK: user and assistant entries
+ * in order, with their transcript uuids. Found under `dir`'s project, else in any project (a session
+ * resumed or forked from another directory). Empty when the session has no transcript yet.
+ */
+export declare function claudeChain(sessionId: string, dir?: string): Promise<Array<{
+    uuid: string;
+    type: 'user' | 'assistant';
+    toolResult?: boolean;
+}>>;
+/** Maps Claude Agent SDK streaming sessions to the normalized runtime protocol. */
+export declare class ClaudeTransport {
+    private readonly command;
+    private readonly cwd;
+    private readonly env;
+    private listeners;
+    private failures;
+    private requestHandler?;
+    /** Whether the workspace had a .claude directory before a sandboxed session started. */
+    private claudeDirectory?;
+    private input;
+    private query?;
+    private pump?;
+    private config?;
+    private threadId;
+    private activeTurn?;
+    private closed;
+    private assistantText;
+    private streamingMessage?;
+    private toolCalls;
+    /** The last rate limit Claude reported, and whether the running turn hit one. */
+    private rateLimit?;
+    private limitedTurn;
+    /** The model's context window and the fill at which Claude compacts it, as Claude reports them (ALPD §57). */
+    private contextWindow?;
+    private compactAt?;
+    /** The compaction running now, from its start to its boundary. */
+    private compaction?;
+    /** The plugin directory that loads the agent's skills, removed on close. */
+    private skillDirectory?;
+    /** Whether a turn ran in this process; before one, an error result is a boot refusal. */
+    private turnsStarted;
+    /** Rejects when the process fails, for a resume that waits for Claude to start. */
+    private bootFailure?;
+    private rejectBoot?;
+    private bootError?;
+    constructor(command: string, cwd: string, env: NodeJS.ProcessEnv);
+    orchestrationContext(): Promise<{
+        runtime: string;
+        observedAt: string;
+        catalogAvailable: boolean;
+        models: {
+            id: string;
+            label: string;
+            description: string;
+            thinking: string[] | undefined;
+        }[];
+        usage: {
+            available: boolean;
+            plan?: undefined;
+            windows?: undefined;
+        } | {
+            available: boolean;
+            plan: any;
+            windows: {
+                name: string;
+                usedPercent: any;
+                remainingPercent: number | null;
+                resetsAt: any;
+            }[];
+        };
+    }>;
+    initialize(): Promise<void>;
+    /** The plan's usage windows before a session starts, from a Claude process that sends no prompt and is closed after. */
+    private probeUsage;
+    onNotification(listener: Listener): () => boolean;
+    onFailure(listener: (error: Error) => void): () => boolean;
+    onRequest(handler: RequestHandler): void;
+    request(method: string, params: any): Promise<any>;
+    /**
+     * How a resume starts. With a base, a session whose transcript does not exist yet is made from the
+     * base's conversation cut at `at` (a fork or rewind, §12.7): Claude writes it, under this session's
+     * id, only when its first prompt runs. Otherwise, the session's own transcript.
+     */
+    private resumeFrom;
+    /**
+     * Waits until Claude has started: its answer to the SDK's initialize request, or the failure that
+     * ends it first. Past BOOT_MS ALP goes on, as any resume does, and a later refusal fails the session.
+     */
+    private booted;
+    private start;
+    /** Reads the window and the compaction threshold Claude resolved for this session, before any turn. */
+    private measureContext;
+    private convertMcp;
+    private consume;
+    private handle;
+    private refuseBoot;
+    private emit;
+    private assistantState;
+    private clearAssistantText;
+    private fail;
+    close(): Promise<void>;
+}
+export {};