@exla/rudder 0.0.0-stage → 3.4.0

package/dist/types.d.ts

@@ -0,0 +1,492 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type CredentialType = "api_key" | "oauth" | "token";
+export type ApiKeyCredential = {
+    type: "api_key";
+    provider: string;
+    key?: string;
+    keyRef?: SecretRef;
+    email?: string;
+    metadata?: Record<string, string>;
+};
+export type TokenCredential = {
+    type: "token";
+    provider: string;
+    token?: string;
+    tokenRef?: SecretRef;
+    expires?: number;
+    email?: string;
+};
+export type OAuthCredential = {
+    type: "oauth";
+    provider: string;
+    access: string;
+    refresh: string;
+    expires: number;
+    clientId?: string;
+    email?: string;
+    accountId?: string;
+    enterpriseUrl?: string;
+    projectId?: string;
+};
+export type SecretRef = {
+    source: "env" | "file" | "exec";
+    provider: string;
+    id: string;
+};
+export type AuthProfileCredential = ApiKeyCredential | TokenCredential | OAuthCredential;
+export type ProfileUsageStats = {
+    lastUsed?: number;
+    cooldownUntil?: number;
+    disabledUntil?: number;
+    disabledReason?: string;
+    errorCount?: number;
+    lastFailureAt?: number;
+};
+export type AuthProfileStore = {
+    version: 1;
+    profiles: Record<string, AuthProfileCredential>;
+    order?: Record<string, string[]>;
+    lastGood?: Record<string, string>;
+    usageStats?: Record<string, ProfileUsageStats>;
+};
+export type RudderConfig = {
+    version: 1;
+    vcs?: VcsMode;
+    defaultBackend: BackendId;
+    lastUsedBackend?: BackendId;
+    mergeStrategy: MergeStrategy;
+    colorMode?: "terminal" | "paper";
+    /** Anonymous usage events. Undefined means on; see src/analytics.ts. */
+    telemetry?: boolean;
+    /** Stable anonymous id for this INSTALL (not a person). Minted on first use. */
+    installId?: string;
+    /** When the one-time telemetry disclosure was printed. */
+    telemetryNoticeShownAt?: string;
+    runPolicy: {
+        sameCheckout: "single-active";
+        concurrentPromptMode: "workspace" | "queue";
+    };
+    acpx: {
+        install: "latest";
+    };
+    backends: {
+        claude?: BackendConfig;
+        codex?: BackendConfig;
+        acpx?: BackendConfig;
+        opencode?: BackendConfig;
+    };
+    board?: {
+        port?: number;
+    };
+    orchestrator?: {
+        maxParallel: number;
+        budget?: {
+            maxTokens?: number;
+        };
+    };
+    /** Continual improvement loop (`rudder improve`); see docs/continual-improvement.md. */
+    improve?: {
+        enabled?: boolean;
+        autonomy?: "observe" | "propose" | "ship";
+        budgetUsd?: number;
+        maxFindings?: number;
+        repoPath?: string;
+        allowedRemote?: string;
+        excludeProjects?: string[];
+        minerModel?: string;
+        judgeModel?: string;
+        advisorModel?: string;
+        workerModel?: string;
+        agentTimeoutMs?: number;
+    };
+};
+export declare const DEFAULT_BOARD_PORT = 4774;
+export type BackendId = "claude" | "codex" | "acpx" | "opencode";
+export type VcsMode = "git" | "jj";
+export type EffortLevel = "low" | "medium" | "high" | "xhigh" | "max";
+export type RunMode = "execute" | "plan" | "rudder-plan" | "review-all" | "main" | "one-off";
+export type MergeStrategy = "merge" | "rebase";
+export type BackendConfig = {
+    profileId?: string;
+    model?: string;
+    effort?: EffortLevel;
+    reasoningEffort?: EffortLevel;
+};
+export type RunStatus = "created" | "running" | "steering" | "verifying" | "completed" | "failed" | "cancelled" | "paused" | "orphaned" | "migrated" | "merge-conflict" | "merged";
+export type DeliveryEvidence = {
+    required: boolean;
+    kind?: "web" | "macos-app" | "release" | "custom" | string;
+    status: "not-requested" | "pending" | "deployed" | "verified" | "blocked" | "failed";
+    target?: string;
+    url?: string;
+    appPath?: string;
+    provider?: string;
+    revision?: string;
+    deploymentId?: string;
+    version?: string;
+    verifiedAt?: string;
+    checks: string[];
+};
+export type UndoEntry = {
+    opId: string;
+    label: string;
+    ts: string;
+    runIds: string[];
+};
+export type NodeStatus = "planned" | "ready" | "running" | "review" | "blocked" | "merged" | "failed";
+export type DepType = "hard" | "soft";
+export type EdgeType = DepType | "judge";
+export type GraphEdge = {
+    id: string;
+    from: string;
+    to: string;
+    type: EdgeType;
+    why?: string;
+    delivered?: boolean;
+};
+export type TaskNode = {
+    id: string;
+    title: string;
+    prompt: string;
+    goal?: string;
+    success?: string;
+    backend: BackendId;
+    model?: string;
+    effort?: EffortLevel;
+    status: NodeStatus;
+    runId?: string;
+    workspace?: {
+        path: string;
+        workspaceName?: string;
+    };
+    jjChangeId?: string;
+    deps: string[];
+    lastLine?: string;
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    reviewState?: "pending" | "approved" | "changes-requested";
+    resolverRunId?: string;
+    merge?: MergeState;
+    supersededBy?: string;
+    source: "planner" | "injection";
+    createdAt: string;
+    updatedAt: string;
+};
+export type RudderGraph = {
+    version: 1;
+    repoRoot: string;
+    integrationChangeId?: string;
+    nodes: Record<string, TaskNode>;
+    edges: Record<string, GraphEdge>;
+    updatedAt: string;
+};
+export type PlanEdge = {
+    on: string;
+    type: EdgeType;
+    why?: string;
+};
+export type PlanNode = {
+    id: string;
+    title: string;
+    prompt: string;
+    goal?: string;
+    success?: string;
+    deps: PlanEdge[];
+    backend?: BackendId;
+    model?: string;
+    effort?: EffortLevel;
+    fileScope?: string[];
+};
+export type PlanDag = {
+    nodes: PlanNode[];
+    edges: Array<{
+        from: string;
+        to: string;
+        type: EdgeType;
+        why?: string;
+    }>;
+};
+export type InferredDep = {
+    node: string;
+    type: DepType;
+};
+export type ReconcileResult = {
+    node: PlanNode;
+    inferredDeps: InferredDep[];
+};
+export type ResolverContext = {
+    mergeChangeId: string;
+    parentChangeIds: string[];
+    conflictedFiles: string[];
+    nodeTitle: string;
+    intoTitle: string;
+    workspacePath: string;
+};
+export type RunRecord = {
+    id: string;
+    status: RunStatus;
+    vcs?: VcsMode;
+    mode?: RunMode;
+    resolverFor?: string;
+    resolverRunId?: string;
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    task: string;
+    taskSummary?: string;
+    taskSummaryLlm?: boolean;
+    backend: BackendId;
+    model?: string;
+    effort?: EffortLevel;
+    createdAt: string;
+    updatedAt: string;
+    repoRoot: string;
+    targetBranch: string;
+    baseCommit: string;
+    workspace: {
+        enabled: boolean;
+        path: string;
+        branch?: string;
+        workspaceName?: string;
+        jjChangeId?: string;
+    };
+    process?: {
+        /** Detached Rudder __worker process that owns verification/lifecycle. */
+        controllerPid?: number;
+        /** Backend CLI child (Claude/Codex/acpx) when one is active. */
+        backendPid?: number;
+        pid?: number;
+        /** Identifies the worker pass that currently owns this run record. A web
+         * redirect starts a new attempt so the superseded worker cannot write a
+         * stale terminal status over the new turn. */
+        attemptId?: string;
+        startedAt?: string;
+        endedAt?: string;
+        exitCode?: number | null;
+        signal?: NodeJS.Signals | null;
+    };
+    currentPrompt?: string;
+    turns?: Array<{
+        ts: string;
+        prompt: string;
+        source: "user" | "steerer" | "regoal";
+    }>;
+    lastUserInputAt?: string;
+    autoSteer?: {
+        count: number;
+        max: number;
+        waitingSince?: string;
+    };
+    session?: {
+        nativeSessionId?: string;
+        acpxSessionId?: string;
+        sessionName?: string;
+    };
+    terminal?: {
+        kind: "tmux";
+        sessionName: string;
+        paneId: string;
+        paneTitle?: string;
+        logPath?: string;
+        launchedAt: string;
+    };
+    verification?: VerificationResult;
+    /** Structured proof for an explicitly requested deploy/install/release. A
+     * completed process is not equivalent to a verified delivery. */
+    delivery?: DeliveryEvidence;
+    merge?: MergeState;
+    sync?: SyncState;
+    /** Durable "an integration conflict happened at some point this run" marker.
+     * `merge.status`/`status` only show the LIVE conflict state and are rewritten
+     * once a resolver or re-merge succeeds, so telemetry (the improve loop's
+     * mergeConflictRate) reads this instead. Set on first conflict, never cleared. */
+    hadMergeConflict?: boolean;
+};
+export type MergeState = {
+    status: "not-started" | "merged" | "conflict" | "failed";
+    attemptedAt?: string;
+    targetBranch?: string;
+    strategy?: MergeStrategy;
+    conflictKind?: "merge" | "rebase";
+    conflictedFiles?: string[];
+    operationId?: string;
+    mergeChangeId?: string;
+    /** Git commit exported for the integrated jj change. */
+    localCommit?: string;
+    /** Whether the configured remote bookmark contains localCommit. */
+    pushed?: boolean;
+    pushedAt?: string;
+    error?: string;
+};
+export type SyncState = {
+    status: "not-started" | "synced" | "conflict" | "failed";
+    attemptedAt?: string;
+    baseBranch?: string;
+    conflictedFiles?: string[];
+    error?: string;
+};
+export type RudderEvent = {
+    ts: string;
+    runId: string;
+    nodeId?: string;
+    type: "run.created" | "run.started" | "run.continued" | "run.detached" | "steerer.waiting" | "steerer.prompt" | "planner.spec" | "backend.output" | "backend.error" | "backend.exit" | "verifier.result" | "run.completed" | "run.failed" | "run.cancelled" | "merge.result" | "sync.result" | "node.created" | "node.ready" | "node.running" | "node.review" | "node.merged" | "node.blocked" | "node.failed" | "plan.proposed" | "plan.reconciled" | "schedule.tick" | "schedule.launched" | "schedule.softDelivered" | "merge.attempt" | "merge.merged" | "merge.conflict" | "resolver.spawned" | "resolver.resolved";
+    message?: string;
+    data?: JsonValue;
+};
+export type RunRequest = {
+    run: RunRecord;
+    prompt: string;
+    contract: string;
+};
+export type BackendAdapter = {
+    id: BackendId;
+    verify(): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    run(request: RunRequest, emit: (event: RudderEvent) => Promise<void>): Promise<number>;
+};
+export type SpecContract = {
+    runId: string;
+    task: string;
+    goal: string;
+    success: string;
+    createdAt: string;
+    repo: {
+        root: string;
+        branch: string;
+        baseCommit: string;
+        status: string[];
+    };
+    instructionsFiles: Array<{
+        path: string;
+        content: string;
+    }>;
+    acceptanceCriteria: string[];
+    suggestedTests: string[];
+};
+export type VerificationResult = {
+    satisfied: string[];
+    missing: string[];
+    notes: string;
+    shouldContinue: boolean;
+};
+export type CloudAuthState = {
+    version: 1;
+    token: string;
+    cloudUrl: string;
+    defaultRuntime?: "fly" | "byo-vm";
+    defaultRegion?: string;
+    byocSshHost?: string;
+    accountId?: string;
+    email?: string;
+    expiresAt?: string;
+    updatedAt: string;
+};
+export type CloudSail = {
+    id: string;
+    status?: string;
+    url?: string;
+    branch?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: JsonValue | undefined;
+};
+export type BoardColumn = "todo" | "running" | "review" | "done";
+export type ProjectEntry = {
+    slug: string;
+    repoRoot: string;
+    name: string;
+    addedAt: string;
+};
+export type ProjectsRegistry = {
+    version: 1;
+    projects: ProjectEntry[];
+};
+export type ProjectSummary = {
+    slug: string;
+    name: string;
+    repoRoot: string;
+    counts: {
+        todo: number;
+        running: number;
+        review: number;
+        done: number;
+        blocked: number;
+        failed: number;
+    };
+    lastActivityAt: string;
+};
+export type BoardNode = {
+    /** Stable graph node id when this run belongs to the DAG; otherwise run id. */
+    id: string;
+    /** Concrete run id once a worker has launched. */
+    runId?: string;
+    title: string;
+    status: RunStatus | NodeStatus;
+    column: BoardColumn;
+    blocked: boolean;
+    backend: BackendId;
+    model?: string;
+    effort?: EffortLevel;
+    lastLine: string | null;
+    tokens: {
+        input: number;
+        output: number;
+    } | null;
+    deps: {
+        hard: string[];
+        soft: string[];
+    };
+    createdAt: string;
+    updatedAt: string;
+    workspace: {
+        path: string;
+        workspaceName?: string;
+    } | null;
+    merge: MergeState | null;
+    delivery?: DeliveryEvidence;
+    /** User-authored follow-up turns, oldest first. The initial task is omitted. */
+    updates: Array<{
+        instruction: string;
+        ts: string;
+        source?: string;
+    }>;
+};
+export type BoardEdge = {
+    from: string;
+    to: string;
+    kind: "hard" | "soft" | "judge";
+};
+export type PlanGate = {
+    id: string;
+    nodeId?: string;
+    question: string;
+    options?: string[];
+    createdAt: string;
+};
+export type MemoryEntry = {
+    text: string;
+    owner?: string;
+    ts?: string;
+};
+export type ActivityEntry = {
+    text: string;
+    kind: "action" | "heartbeat";
+    ts?: string;
+};
+export type BoardSnapshot = {
+    slug: string;
+    name: string;
+    generatedAt: string;
+    nodes: BoardNode[];
+    edges: BoardEdge[];
+    gates: PlanGate[];
+    memory: MemoryEntry[];
+    activity?: ActivityEntry[];
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+export const DEFAULT_BOARD_PORT = 4774;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AA0HA,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,CAAC"}

package/dist/usage.d.ts

@@ -0,0 +1,198 @@
+export type Provider = "claude" | "codex";
+export type UsageRange = "7d" | "30d" | "90d";
+/** USD per million tokens. */
+export type ModelPrice = {
+    input: number;
+    output: number;
+    cacheWrite: number;
+    cacheRead: number;
+};
+export type Totals = {
+    input: number;
+    output: number;
+    cacheWrite: number;
+    cacheRead: number;
+    /** Estimated USD at API list rates. */
+    cost: number;
+    /** USD that cache reads saved versus paying full input price. */
+    cacheSavings: number;
+    /** API calls (Claude assistant messages / Codex responses). */
+    calls: number;
+};
+export type UsageEvent = {
+    ts: string;
+    provider: Provider;
+    model: string;
+    cwd: string;
+    sessionId: string;
+    input: number;
+    output: number;
+    cacheWrite: number;
+    cacheRead: number;
+};
+export type DayBucket = {
+    day: string;
+    claude: Totals;
+    codex: Totals;
+};
+export type ModelRow = {
+    provider: Provider;
+    model: string;
+    totals: Totals;
+    sessions: number;
+};
+export type SessionRow = {
+    id: string;
+    provider: Provider;
+    model: string;
+    startedAt: string;
+    lastAt: string;
+    cwd: string;
+    totals: Totals;
+};
+export type ProjectRow = {
+    key: string;
+    name: string;
+    slug: string | null;
+    totals: Totals;
+    sessions: SessionRow[];
+};
+export type TokenUsageReport = {
+    range: UsageRange;
+    since: string;
+    generatedAt: string;
+    days: DayBucket[];
+    providers: Record<Provider, Totals>;
+    total: Totals;
+    models: ModelRow[];
+    projects: ProjectRow[];
+    scannedFiles: number;
+    pricingNote: string;
+};
+export declare function priceFor(model: string): ModelPrice | null;
+export declare function emptyTotals(): Totals;
+export declare function addEvent(totals: Totals, event: UsageEvent): void;
+export declare function claudeConfigDir(): string;
+export declare function codexHomeDir(): string;
+export declare function rangeSince(range: UsageRange, now?: Date): Date;
+/** Local calendar day for a timestamp, as YYYY-MM-DD. */
+export declare function localDay(ts: string | Date): string;
+/**
+ * Claude Code writes one line per assistant message, and a streamed message can
+ * appear several times (same `message.id` + `requestId`) with growing usage; the
+ * last line is the complete one, so later occurrences replace earlier ones.
+ */
+export declare function parseClaudeLog(file: string): Promise<UsageEvent[]>;
+/**
+ * Codex writes `token_count` events carrying a cumulative `total_token_usage`;
+ * each event's delta from the previous one is one response's usage, attributed
+ * to that event's timestamp and the model of the latest `turn_context`.
+ * Cached input is a subset of input, so billable input = input − cached.
+ */
+export declare function parseCodexLog(file: string): Promise<UsageEvent[]>;
+export type ProjectLookup = {
+    slug: string;
+    name: string;
+    repoRoot: string;
+}[];
+/** Nearest ancestor (inclusive) that is a git/jj checkout, or null. Cached per dir. */
+export declare function nearestRepoRoot(cwd: string, exists?: (p: string) => boolean): string | null;
+/**
+ * Which workspace a session belongs to. The session's own checkout names it:
+ * a Rudder worker workspace (`<repo>/.rudder-workspaces/<name>`) counts for
+ * `<repo>`, any other cwd for its nearest git/jj root, a bare directory for
+ * itself. A registered project wins only when its root IS that checkout —
+ * a project registered at `~/code` must not swallow every repo beneath it —
+ * or when the cwd is not inside any checkout at all.
+ */
+export declare function projectFor(cwd: string, projects: ProjectLookup, repoRootOf?: (cwd: string) => string | null): {
+    key: string;
+    name: string;
+    slug: string | null;
+};
+export declare function scanTokenUsage(opts: {
+    range: UsageRange;
+    projects?: ProjectLookup;
+    claudeProjectsRoot?: string;
+    codexSessionsRoot?: string;
+    now?: Date;
+}): Promise<TokenUsageReport>;
+export type QuotaWindow = {
+    label: string;
+    percent: number;
+    resetsAt: string | null;
+};
+export type AccountQuota = {
+    provider: Provider;
+    email: string | null;
+    plan: string | null;
+    windows: QuotaWindow[];
+    /** Human-readable reason a request would be rejected or throttled right now (rate limit hit, credits depleted), or null when clear. */
+    blocked: string | null;
+    /** Human-readable reason the meters are missing, with the fix. */
+    error: string | null;
+    fetchedAt: string;
+};
+export type QuotaReport = {
+    accounts: AccountQuota[];
+    fetchedAt: string;
+    ttlSeconds: number;
+};
+/**
+ * Pure: Claude's `/api/oauth/usage` body → meters. Newer accounts stop
+ * populating `seven_day_opus`/`seven_day_sonnet` (both come back `null`) and
+ * report the active model's weekly sub-limit in `usage.limits[]` instead,
+ * keyed by `scope.model.display_name` — e.g. a Fable-heavy week shows a
+ * higher "Weekly · Fable" percent than the blended `seven_day` figure.
+ */
+export declare function parseClaudeQuota(usage: any, profile: any, fallbackPlan: string | null): Omit<AccountQuota, "fetchedAt" | "provider">;
+/** Pure: Codex's `/backend-api/wham/usage` body → meters. */
+export declare function parseCodexQuota(body: any): Omit<AccountQuota, "fetchedAt" | "provider">;
+export declare function fetchQuota(opts?: {
+    force?: boolean;
+}): Promise<QuotaReport>;
+export type ProcessKind = "rudder" | "claude" | "codex" | "opencode" | "other";
+export type ProcessRow = {
+    pid: number;
+    ppid: number;
+    kind: ProcessKind;
+    cpu: number;
+    /** Resident set, bytes. */
+    rss: number;
+    elapsed: string;
+    command: string;
+};
+export type MachineReport = {
+    at: string;
+    cpus: number;
+    load: number[];
+    totalMem: number;
+    freeMem: number;
+    rudder: {
+        cpu: number;
+        rss: number;
+        pid: number;
+    };
+    processes: ProcessRow[];
+    byKind: Record<ProcessKind, {
+        cpu: number;
+        rss: number;
+        count: number;
+    }>;
+};
+/**
+ * Classify by the EXECUTABLE, not the whole command line: a Claude worker's
+ * argv carries `--settings ~/.rudder/signals/...`, so matching "rudder"
+ * anywhere in the line filed every agent under rudder. For interpreters
+ * (`node`, `bun`) the script path is the executable.
+ */
+export declare function classifyCommand(command: string): ProcessKind;
+/** Pure: `ps -axo pid=,ppid=,pcpu=,rss=,etime=,args=` → agent-related rows. */
+export declare function parsePsOutput(text: string): ProcessRow[];
+/**
+ * `os.freemem()` on macOS counts only truly free pages, so a healthy Mac reads
+ * as 99% used. vm_stat's inactive + speculative + purgeable pages are
+ * reclaimable and count as available, which is what Activity Monitor shows.
+ */
+export declare function parseVmStat(text: string): number | null;
+export declare function machineResources(): Promise<MachineReport>;