praxis-agent 0.36.0 → 0.37.0

package/dist/application/team-workspace.d.ts

@@ -0,0 +1,29 @@
+export interface TeamWorkspace {
+    readonly cwd: string;
+    readonly branch: string | null;
+}
+export interface TeamWorkspaceInput {
+    readonly teamId: string;
+    readonly taskId: string;
+    readonly generation: number;
+    readonly access: 'read-only' | 'write';
+}
+export interface TeamWorkspaceProvider {
+    acquire(input: TeamWorkspaceInput): Promise<TeamWorkspace>;
+}
+export declare class NativeTeamWorkspaceProvider implements TeamWorkspaceProvider {
+    private readonly nativeRoot;
+    private readonly cwd;
+    private readonly projectIdentity;
+    private readonly gitRoot;
+    private readonly initialHead;
+    private constructor();
+    static open(options: {
+        nativeRoot: string;
+        cwd: string;
+        projectIdentity: string;
+    }): Promise<NativeTeamWorkspaceProvider>;
+    acquire(input: TeamWorkspaceInput): Promise<TeamWorkspace>;
+    private hasBranch;
+}
+//# sourceMappingURL=team-workspace.d.ts.map

package/dist/application/team-workspace.js

@@ -0,0 +1,197 @@
+import { execFile } from 'node:child_process';
+import { lstat, mkdir, realpath } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { resolveProjectIdentity } from '../platform/project-identity.js';
+import { sanitizeProjectPath } from '../platform/project-path-key.js';
+import { parseTeamId } from '../core/team-ownership.js';
+const execFileAsync = promisify(execFile);
+async function git(cwd, args) {
+    return (await execFileAsync('git', ['-C', cwd, ...args], { encoding: 'utf8' })).stdout.trim();
+}
+async function canonical(path) {
+    try {
+        return await realpath(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return resolve(path);
+        throw error;
+    }
+}
+function assertInput(input) {
+    parseTeamId(input.teamId);
+    if (typeof input.taskId !== 'string' || input.taskId.trim() === '')
+        throw new Error('Invalid Team task ID');
+    if (!Number.isSafeInteger(input.generation) || input.generation <= 0)
+        throw new Error('Invalid Team generation');
+    if (input.access !== 'read-only' && input.access !== 'write')
+        throw new Error('Invalid Team workspace access');
+}
+async function registeredWorktrees(root) {
+    const output = await git(root, ['worktree', 'list', '--porcelain']);
+    const result = new Map();
+    let path;
+    for (const line of output.split('\n')) {
+        if (line.startsWith('worktree '))
+            path = resolve(line.slice('worktree '.length));
+        else if (line.startsWith('branch ') && path) {
+            result.set(await canonical(path), line.slice('branch '.length));
+            path = undefined;
+        }
+    }
+    if (path)
+        result.set(await canonical(path), '');
+    return result;
+}
+export class NativeTeamWorkspaceProvider {
+    nativeRoot;
+    cwd;
+    projectIdentity;
+    gitRoot;
+    initialHead;
+    constructor(nativeRoot, cwd, projectIdentity, gitRoot, initialHead) {
+        this.nativeRoot = nativeRoot;
+        this.cwd = cwd;
+        this.projectIdentity = projectIdentity;
+        this.gitRoot = gitRoot;
+        this.initialHead = initialHead;
+    }
+    static async open(options) {
+        if (typeof options.nativeRoot !== 'string' ||
+            options.nativeRoot.trim() === '')
+            throw new Error('Invalid native Team root');
+        const canonicalCwd = await canonical(options.cwd);
+        const identity = await resolveProjectIdentity(canonicalCwd);
+        if (identity !== options.projectIdentity)
+            throw new Error('Team workspace project identity mismatch');
+        let gitRoot = null;
+        let initialHead = null;
+        try {
+            gitRoot = await canonical(await git(canonicalCwd, ['rev-parse', '--show-toplevel']));
+            initialHead = await git(gitRoot, ['rev-parse', 'HEAD']);
+        }
+        catch {
+            // A read-only member can safely use a non-Git project root.
+        }
+        return new NativeTeamWorkspaceProvider(await canonical(options.nativeRoot), canonicalCwd, options.projectIdentity, gitRoot, initialHead);
+    }
+    async acquire(input) {
+        assertInput(input);
+        if (input.access === 'read-only') {
+            return { cwd: this.cwd, branch: null };
+        }
+        if (this.gitRoot === null || this.initialHead === null)
+            throw new Error('Team write workspace requires a Git repository');
+        const hash = createHash('sha256')
+            .update(`${this.projectIdentity}\0${input.teamId}\0${input.taskId}\0${input.generation}`)
+            .digest('hex')
+            .slice(0, 24);
+        const branch = `praxis/team/${input.teamId}/${hash}`;
+        const path = resolve(this.nativeRoot, 'state', 'team-worktrees', sanitizeProjectPath(this.projectIdentity), input.teamId, hash);
+        if (!isAbsolute(path) ||
+            !isAbsolute(this.nativeRoot) ||
+            !isPathWithin(this.nativeRoot, path))
+            throw new Error('Invalid Team workspace path');
+        await assertSafeParents(this.nativeRoot, path);
+        let pathExists = false;
+        try {
+            const entry = await lstat(path);
+            if (entry.isSymbolicLink())
+                throw new Error('Team worktree path must not be a symlink');
+            if (!entry.isDirectory())
+                throw new Error(`Team worktree path is not a directory: ${path}`);
+            pathExists = true;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const currentHead = await git(this.gitRoot, ['rev-parse', 'HEAD']);
+        const registered = await registeredWorktrees(this.gitRoot);
+        const registeredBranch = registered.get(path);
+        const branchExists = await this.hasBranch(branch);
+        if (!pathExists && !branchExists) {
+            await mkdir(resolve(path, '..'), { recursive: true });
+            try {
+                await git(this.gitRoot, [
+                    'worktree',
+                    'add',
+                    '-b',
+                    branch,
+                    path,
+                    currentHead,
+                ]);
+            }
+            catch (error) {
+                throw new Error(`Could not create Team worktree: ${error.message}`);
+            }
+            return { cwd: path, branch };
+        }
+        if (!pathExists || !branchExists)
+            throw new Error(`Team workspace collision at ${path}`);
+        if (registeredBranch !== `refs/heads/${branch}`)
+            throw new Error(`Team worktree registration mismatch at ${path}`);
+        if ((await canonical(path)) !== path)
+            throw new Error(`Team worktree path must be canonical: ${path}`);
+        const worktreeRoot = await canonical(await git(path, ['rev-parse', '--show-toplevel']));
+        if (worktreeRoot !== path ||
+            (await resolveProjectIdentity(path)) !== this.projectIdentity)
+            throw new Error(`Team worktree repository mismatch at ${path}`);
+        const currentBranch = await git(path, [
+            'symbolic-ref',
+            '--quiet',
+            '--short',
+            'HEAD',
+        ]);
+        if (currentBranch !== branch)
+            throw new Error(`Team worktree branch mismatch at ${path}`);
+        return { cwd: path, branch };
+    }
+    async hasBranch(branch) {
+        try {
+            await git(this.gitRoot, [
+                'show-ref',
+                '--verify',
+                '--quiet',
+                `refs/heads/${branch}`,
+            ]);
+            return true;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 1)
+                return false;
+            throw error;
+        }
+    }
+}
+function isPathWithin(root, candidate) {
+    const path = relative(resolve(root), resolve(candidate));
+    return path === '' || (!path.startsWith('..') && !isAbsolute(path));
+}
+async function assertSafeParents(root, path) {
+    let current = resolve(path, '..');
+    const nativeRoot = resolve(root);
+    for (;;) {
+        try {
+            const entry = await lstat(current);
+            if (entry.isSymbolicLink())
+                throw new Error(`Team worktree parent must not be a symlink: ${current}`);
+            if (!entry.isDirectory())
+                throw new Error(`Team worktree parent is not a directory: ${current}`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (current === nativeRoot || !isPathWithin(nativeRoot, current))
+            return;
+        const parent = resolve(current, '..');
+        if (parent === current)
+            return;
+        current = parent;
+    }
+}
+//# sourceMappingURL=team-workspace.js.map

package/dist/application/transcript-projection.d.ts

@@ -28,6 +28,8 @@ export type TranscriptDisplayItem = {
 };
 export declare function activeEvents(events: readonly TranscriptEvent[], checkpoint?: string): TranscriptEvent[];
 export declare function projectActiveMessages(events: readonly TranscriptEvent[], checkpoint?: string): ModelMessage[];
+/** Return tool calls whose results are absent from the selected active branch. */
+export declare function unresolvedActiveToolCallIds(messages: readonly ModelMessage[]): string[];
 export declare function projectTranscriptDisplay(events: readonly TranscriptEvent[], checkpoint?: string): TranscriptDisplayItem[];
 export declare function lastUserPrompt(events: readonly TranscriptEvent[], checkpoint?: string): string | null;
 //# sourceMappingURL=transcript-projection.d.ts.map

package/dist/application/transcript-projection.js

@@ -40,7 +40,36 @@ export function activeEvents(events, checkpoint) {
     return selected.reverse();
 }
 export function projectActiveMessages(events, checkpoint) {
-    return activeEvents(events, checkpoint).flatMap((event) => event.kind === 'messages' ? [...event.messages] : []);
+    const messages = [];
+    for (const event of activeEvents(events, checkpoint)) {
+        if (event.kind === 'context-boundary') {
+            messages.length = 0;
+            continue;
+        }
+        if (event.kind === 'context-summary') {
+            messages.push({ role: 'user', content: event.summary });
+            continue;
+        }
+        if (event.kind === 'tool-execution-started')
+            continue;
+        messages.push(...event.messages);
+    }
+    return messages;
+}
+/** Return tool calls whose results are absent from the selected active branch. */
+export function unresolvedActiveToolCallIds(messages) {
+    const calls = new Set();
+    const results = new Set();
+    for (const message of messages) {
+        if (message.role === 'assistant') {
+            for (const call of message.toolCalls ?? [])
+                calls.add(call.id);
+        }
+        else if (message.role === 'tool') {
+            results.add(message.toolCallId);
+        }
+    }
+    return [...calls].filter((id) => !results.has(id));
 }
 export function projectTranscriptDisplay(events, checkpoint) {
     const items = [];

package/dist/cli/interactive.d.ts

@@ -7,6 +7,7 @@ import type { ClaudeInteractiveToolCallbacks } from '../tools/claude-interactive
 import { type ClaudePermissionMode } from '../permissions/claude-permission-resolver.js';
 import { type TranscriptItem, type TuiDisplayMetadata } from './tui/claude-style.js';
 import { type TuiMemoryFiles } from './tui/memory-files.js';
+import { type TuiHistoryChange } from './tui/tui-view-model.js';
 import { type TuiDiffSnapshot } from './tui/git-diff.js';
 import { type TuiPermissionBehavior, type TuiPermissionRule } from './tui/permission-settings.js';
 import { type RecentlyDeniedStore } from './tui/recently-denied.js';
@@ -196,6 +197,12 @@ interface InteractiveAppProps {
     releaseNotesLoader?: (configRoot: string) => Promise<string>;
     settingSources?: readonly ClaudeResourceScope[];
 }
+export interface InteractiveHistoryState {
+    readonly items: TranscriptItem[];
+    readonly change: TuiHistoryChange;
+}
+/** Advances the React-owned transcript plus its exact local mutation fact. */
+export declare function advanceInteractiveHistoryState(current: InteractiveHistoryState, items: TranscriptItem[], changedFrom: number): InteractiveHistoryState;
 export declare function InteractiveApp({ dataPlane, configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory, initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, doctorLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, notificationDelayMs, elicitationUrlOpener, releaseNotesLoader, settingSources, }: InteractiveAppProps): import("react").JSX.Element;
 export declare function runInteractive(options: {
     dataPlane?: DataPlane;