@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/components/TeammateViewHeader.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { Box, Text } from '../ink.js';
+import { useAppState } from '../state/AppState.js';
+import { getViewedTeammateTask } from '../state/selectors.js';
+import { toInkColor } from '../utils/ink.js';
+import { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js';
+import { OffscreenFreeze } from './OffscreenFreeze.js';
+/**
+ * Header shown when viewing a teammate's transcript.
+ * Displays teammate name (colored), task description, and exit hint.
+ */
+export function TeammateViewHeader() {
+    const $ = _c(14);
+    const viewedTeammate = useAppState(_temp);
+    if (!viewedTeammate) {
+        return null;
+    }
+    let t0;
+    if ($[0] !== viewedTeammate.identity.color) {
+        t0 = toInkColor(viewedTeammate.identity.color);
+        $[0] = viewedTeammate.identity.color;
+        $[1] = t0;
+    }
+    else {
+        t0 = $[1];
+    }
+    const nameColor = t0;
+    let t1;
+    if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+        t1 = _jsx(Text, { children: "Viewing " });
+        $[2] = t1;
+    }
+    else {
+        t1 = $[2];
+    }
+    let t2;
+    if ($[3] !== nameColor || $[4] !== viewedTeammate.identity.agentName) {
+        t2 = _jsxs(Text, { color: nameColor, bold: true, children: ["@", viewedTeammate.identity.agentName] });
+        $[3] = nameColor;
+        $[4] = viewedTeammate.identity.agentName;
+        $[5] = t2;
+    }
+    else {
+        t2 = $[5];
+    }
+    let t3;
+    if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+        t3 = _jsxs(Text, { dimColor: true, children: [" \xB7 ", _jsx(KeyboardShortcutHint, { shortcut: "esc", action: "return" })] });
+        $[6] = t3;
+    }
+    else {
+        t3 = $[6];
+    }
+    let t4;
+    if ($[7] !== t2) {
+        t4 = _jsxs(Box, { children: [t1, t2, t3] });
+        $[7] = t2;
+        $[8] = t4;
+    }
+    else {
+        t4 = $[8];
+    }
+    let t5;
+    if ($[9] !== viewedTeammate.prompt) {
+        t5 = _jsx(Text, { dimColor: true, children: viewedTeammate.prompt });
+        $[9] = viewedTeammate.prompt;
+        $[10] = t5;
+    }
+    else {
+        t5 = $[10];
+    }
+    let t6;
+    if ($[11] !== t4 || $[12] !== t5) {
+        t6 = _jsx(OffscreenFreeze, { children: _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [t4, t5] }) });
+        $[11] = t4;
+        $[12] = t5;
+        $[13] = t6;
+    }
+    else {
+        t6 = $[13];
+    }
+    return t6;
+}
+function _temp(s) {
+    return getViewedTeammateTask(s);
+}

package/dist/src/components/TeleportError.js

@@ -0,0 +1,191 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { useEffect, useState } from 'react';
+import { checkIsGitClean, checkNeedsClaudeAiLogin } from '../utils/background/remote/preconditions.js';
+import { gracefulShutdownSync } from '../utils/gracefulShutdown.js';
+import { Box, Text } from '../ink.js';
+import { ConsoleOAuthFlow } from './ConsoleOAuthFlow.js';
+import { Select } from './CustomSelect/index.js';
+import { Dialog } from './design-system/Dialog.js';
+import { TeleportStash } from './TeleportStash.js';
+// Module-level sentinel so the default parameter has stable identity.
+// Previously `= new Set()` created a fresh Set every render, which put
+// a new object in checkErrors' deps and caused the mount effect to
+// re-fire on every render.
+const EMPTY_ERRORS_TO_IGNORE = new Set();
+export function TeleportError(t0) {
+    const $ = _c(18);
+    const { onComplete, errorsToIgnore: t1 } = t0;
+    const errorsToIgnore = t1 === undefined ? EMPTY_ERRORS_TO_IGNORE : t1;
+    const [currentError, setCurrentError] = useState(null);
+    const [isLoggingIn, setIsLoggingIn] = useState(false);
+    let t2;
+    if ($[0] !== errorsToIgnore || $[1] !== onComplete) {
+        t2 = async () => {
+            const currentErrors = await getTeleportErrors();
+            const filteredErrors = new Set(Array.from(currentErrors).filter(error => !errorsToIgnore.has(error)));
+            if (filteredErrors.size === 0) {
+                onComplete();
+                return;
+            }
+            if (filteredErrors.has("needsLogin")) {
+                setCurrentError("needsLogin");
+            }
+            else {
+                if (filteredErrors.has("needsGitStash")) {
+                    setCurrentError("needsGitStash");
+                }
+            }
+        };
+        $[0] = errorsToIgnore;
+        $[1] = onComplete;
+        $[2] = t2;
+    }
+    else {
+        t2 = $[2];
+    }
+    const checkErrors = t2;
+    let t3;
+    let t4;
+    if ($[3] !== checkErrors) {
+        t3 = () => {
+            checkErrors();
+        };
+        t4 = [checkErrors];
+        $[3] = checkErrors;
+        $[4] = t3;
+        $[5] = t4;
+    }
+    else {
+        t3 = $[4];
+        t4 = $[5];
+    }
+    useEffect(t3, t4);
+    const onCancel = _temp;
+    let t5;
+    if ($[6] !== checkErrors) {
+        t5 = () => {
+            setIsLoggingIn(false);
+            checkErrors();
+        };
+        $[6] = checkErrors;
+        $[7] = t5;
+    }
+    else {
+        t5 = $[7];
+    }
+    const handleLoginComplete = t5;
+    let t6;
+    if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+        t6 = () => {
+            setIsLoggingIn(true);
+        };
+        $[8] = t6;
+    }
+    else {
+        t6 = $[8];
+    }
+    const handleLoginWithClaudeAI = t6;
+    let t7;
+    if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+        t7 = value => {
+            if (value === "login") {
+                handleLoginWithClaudeAI();
+            }
+            else {
+                onCancel();
+            }
+        };
+        $[9] = t7;
+    }
+    else {
+        t7 = $[9];
+    }
+    const handleLoginDialogSelect = t7;
+    let t8;
+    if ($[10] !== checkErrors) {
+        t8 = () => {
+            checkErrors();
+        };
+        $[10] = checkErrors;
+        $[11] = t8;
+    }
+    else {
+        t8 = $[11];
+    }
+    const handleStashComplete = t8;
+    if (!currentError) {
+        return null;
+    }
+    switch (currentError) {
+        case "needsGitStash":
+            {
+                let t9;
+                if ($[12] !== handleStashComplete) {
+                    t9 = _jsx(TeleportStash, { onStashAndContinue: handleStashComplete, onCancel: onCancel });
+                    $[12] = handleStashComplete;
+                    $[13] = t9;
+                }
+                else {
+                    t9 = $[13];
+                }
+                return t9;
+            }
+        case "needsLogin":
+            {
+                if (isLoggingIn) {
+                    let t9;
+                    if ($[14] !== handleLoginComplete) {
+                        t9 = _jsx(ConsoleOAuthFlow, { onDone: handleLoginComplete, mode: "login", forceLoginMethod: "claudeai" });
+                        $[14] = handleLoginComplete;
+                        $[15] = t9;
+                    }
+                    else {
+                        t9 = $[15];
+                    }
+                    return t9;
+                }
+                let t9;
+                if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+                    t9 = _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Teleport requires a Claude.ai account." }), _jsx(Text, { dimColor: true, children: "Your Claude Pro/Max subscription will be used by Context Code." })] });
+                    $[16] = t9;
+                }
+                else {
+                    t9 = $[16];
+                }
+                let t10;
+                if ($[17] === Symbol.for("react.memo_cache_sentinel")) {
+                    t10 = _jsxs(Dialog, { title: "Log in to Claude", onCancel: onCancel, children: [t9, _jsx(Select, { options: [{
+                                        label: "Login with Claude account",
+                                        value: "login"
+                                    }, {
+                                        label: "Exit",
+                                        value: "exit"
+                                    }], onChange: handleLoginDialogSelect })] });
+                    $[17] = t10;
+                }
+                else {
+                    t10 = $[17];
+                }
+                return t10;
+            }
+    }
+}
+/**
+ * Gets current teleport errors that need to be resolved
+ * @returns Set of teleport error types that need to be handled
+ */
+function _temp() {
+    gracefulShutdownSync(0);
+}
+export async function getTeleportErrors() {
+    const errors = new Set();
+    const [needsLogin, isGitClean] = await Promise.all([checkNeedsClaudeAiLogin(), checkIsGitClean()]);
+    if (needsLogin) {
+        errors.add('needsLogin');
+    }
+    if (!isGitClean) {
+        errors.add('needsGitStash');
+    }
+    return errors;
+}

package/dist/src/components/TeleportProgress.js

@@ -0,0 +1,130 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import { useState } from 'react';
+import { Box, Text, useAnimationFrame } from '../ink.js';
+import { AppStateProvider } from '../state/AppState.js';
+import { checkOutTeleportedSessionBranch, processMessagesForTeleportResume, teleportResumeCodeSession } from '../utils/teleport.js';
+const SPINNER_FRAMES = ['◐', '◓', '◑', '◒'];
+const STEPS = [{
+        key: 'validating',
+        label: 'Validating session'
+    }, {
+        key: 'fetching_logs',
+        label: 'Fetching session logs'
+    }, {
+        key: 'fetching_branch',
+        label: 'Getting branch info'
+    }, {
+        key: 'checking_out',
+        label: 'Checking out branch'
+    }];
+export function TeleportProgress(t0) {
+    const $ = _c(16);
+    const { currentStep, sessionId } = t0;
+    const [ref, time] = useAnimationFrame(100);
+    const frame = Math.floor(time / 100) % SPINNER_FRAMES.length;
+    let t1;
+    if ($[0] !== currentStep) {
+        t1 = s => s.key === currentStep;
+        $[0] = currentStep;
+        $[1] = t1;
+    }
+    else {
+        t1 = $[1];
+    }
+    const currentStepIndex = STEPS.findIndex(t1);
+    const t2 = SPINNER_FRAMES[frame];
+    let t3;
+    if ($[2] !== t2) {
+        t3 = _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "claude", children: [t2, " Teleporting session\u2026"] }) });
+        $[2] = t2;
+        $[3] = t3;
+    }
+    else {
+        t3 = $[3];
+    }
+    let t4;
+    if ($[4] !== sessionId) {
+        t4 = sessionId && _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: sessionId }) });
+        $[4] = sessionId;
+        $[5] = t4;
+    }
+    else {
+        t4 = $[5];
+    }
+    let t5;
+    if ($[6] !== currentStepIndex || $[7] !== frame) {
+        t5 = STEPS.map((step, index) => {
+            const isComplete = index < currentStepIndex;
+            const isCurrent = index === currentStepIndex;
+            const isPending = index > currentStepIndex;
+            let icon;
+            let color;
+            if (isComplete) {
+                icon = figures.tick;
+                color = "green";
+            }
+            else {
+                if (isCurrent) {
+                    icon = SPINNER_FRAMES[frame];
+                    color = "claude";
+                }
+                else {
+                    icon = figures.circle;
+                    color = undefined;
+                }
+            }
+            return _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 2, children: _jsx(Text, { color: color, dimColor: isPending, children: icon }) }), _jsx(Text, { dimColor: isPending, bold: isCurrent, children: step.label })] }, step.key);
+        });
+        $[6] = currentStepIndex;
+        $[7] = frame;
+        $[8] = t5;
+    }
+    else {
+        t5 = $[8];
+    }
+    let t6;
+    if ($[9] !== t5) {
+        t6 = _jsx(Box, { flexDirection: "column", marginLeft: 2, children: t5 });
+        $[9] = t5;
+        $[10] = t6;
+    }
+    else {
+        t6 = $[10];
+    }
+    let t7;
+    if ($[11] !== ref || $[12] !== t3 || $[13] !== t4 || $[14] !== t6) {
+        t7 = _jsxs(Box, { ref: ref, flexDirection: "column", paddingX: 1, paddingY: 1, children: [t3, t4, t6] });
+        $[11] = ref;
+        $[12] = t3;
+        $[13] = t4;
+        $[14] = t6;
+        $[15] = t7;
+    }
+    else {
+        t7 = $[15];
+    }
+    return t7;
+}
+/**
+ * Teleports to a remote session with progress UI rendered into the existing root.
+ * Fetches the session, checks out the branch, and returns the result.
+ */
+export async function teleportWithProgress(root, sessionId) {
+    // Capture the setState function from the rendered component
+    let setStep = () => { };
+    function TeleportProgressWrapper() {
+        const [step, _setStep] = useState('validating');
+        setStep = _setStep;
+        return _jsx(TeleportProgress, { currentStep: step, sessionId: sessionId });
+    }
+    root.render(_jsx(AppStateProvider, { children: _jsx(TeleportProgressWrapper, {}) }));
+    const result = await teleportResumeCodeSession(sessionId, setStep);
+    setStep('checking_out');
+    const { branchName, branchError } = await checkOutTeleportedSessionBranch(result.branch);
+    return {
+        messages: processMessagesForTeleportResume(result.log, branchError),
+        branchName
+    };
+}

package/dist/src/components/TeleportRepoMismatchDialog.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { useState } from 'react';
+import { Box, Text } from '../ink.js';
+import { getDisplayPath } from '../utils/file.js';
+import { removePathFromRepo, validateRepoAtPath } from '../utils/githubRepoPathMapping.js';
+import { Select } from './CustomSelect/index.js';
+import { Dialog } from './design-system/Dialog.js';
+import { Spinner } from './Spinner.js';
+export function TeleportRepoMismatchDialog(t0) {
+    const $ = _c(18);
+    const { targetRepo, initialPaths, onSelectPath, onCancel } = t0;
+    const [availablePaths, setAvailablePaths] = useState(initialPaths);
+    const [errorMessage, setErrorMessage] = useState(null);
+    const [validating, setValidating] = useState(false);
+    let t1;
+    if ($[0] !== availablePaths || $[1] !== onCancel || $[2] !== onSelectPath || $[3] !== targetRepo) {
+        t1 = async (value) => {
+            if (value === "cancel") {
+                onCancel();
+                return;
+            }
+            setValidating(true);
+            setErrorMessage(null);
+            const isValid = await validateRepoAtPath(value, targetRepo);
+            if (isValid) {
+                onSelectPath(value);
+                return;
+            }
+            removePathFromRepo(targetRepo, value);
+            const updatedPaths = availablePaths.filter(p => p !== value);
+            setAvailablePaths(updatedPaths);
+            setValidating(false);
+            setErrorMessage(`${getDisplayPath(value)} no longer contains the correct repository. Select another path.`);
+        };
+        $[0] = availablePaths;
+        $[1] = onCancel;
+        $[2] = onSelectPath;
+        $[3] = targetRepo;
+        $[4] = t1;
+    }
+    else {
+        t1 = $[4];
+    }
+    const handleChange = t1;
+    let t2;
+    if ($[5] !== availablePaths) {
+        let t3;
+        if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+            t3 = {
+                label: "Cancel",
+                value: "cancel"
+            };
+            $[7] = t3;
+        }
+        else {
+            t3 = $[7];
+        }
+        t2 = [...availablePaths.map(_temp), t3];
+        $[5] = availablePaths;
+        $[6] = t2;
+    }
+    else {
+        t2 = $[6];
+    }
+    const options = t2;
+    let t3;
+    if ($[8] !== availablePaths.length || $[9] !== errorMessage || $[10] !== handleChange || $[11] !== options || $[12] !== targetRepo || $[13] !== validating) {
+        t3 = availablePaths.length > 0 ? _jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", gap: 1, children: [errorMessage && _jsx(Text, { color: "error", children: errorMessage }), _jsxs(Text, { children: ["Open Context Code in ", _jsx(Text, { bold: true, children: targetRepo }), ":"] })] }), validating ? _jsxs(Box, { children: [_jsx(Spinner, {}), _jsx(Text, { children: " Validating repository\u2026" })] }) : _jsx(Select, { options: options, onChange: value_0 => void handleChange(value_0) })] }) : _jsxs(Box, { flexDirection: "column", gap: 1, children: [errorMessage && _jsx(Text, { color: "error", children: errorMessage }), _jsxs(Text, { dimColor: true, children: ["Run context --teleport from a checkout of ", targetRepo] })] });
+        $[8] = availablePaths.length;
+        $[9] = errorMessage;
+        $[10] = handleChange;
+        $[11] = options;
+        $[12] = targetRepo;
+        $[13] = validating;
+        $[14] = t3;
+    }
+    else {
+        t3 = $[14];
+    }
+    let t4;
+    if ($[15] !== onCancel || $[16] !== t3) {
+        t4 = _jsx(Dialog, { title: "Teleport to Repo", onCancel: onCancel, color: "background", children: t3 });
+        $[15] = onCancel;
+        $[16] = t3;
+        $[17] = t4;
+    }
+    else {
+        t4 = $[17];
+    }
+    return t4;
+}
+function _temp(path) {
+    return {
+        label: _jsxs(Text, { children: ["Use ", _jsx(Text, { bold: true, children: getDisplayPath(path) })] }),
+        value: path
+    };
+}

package/dist/src/components/TeleportResumeWrapper.js

@@ -0,0 +1,158 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { useEffect } from 'react';
+import { logEvent } from '../services/analytics/index.js';
+import { useTeleportResume } from '../hooks/useTeleportResume.js';
+import { Box, Text } from '../ink.js';
+import { useKeybinding } from '../keybindings/useKeybinding.js';
+import { ResumeTask } from './ResumeTask.js';
+import { Spinner } from './Spinner.js';
+/**
+ * Wrapper component that manages the full teleport resume flow,
+ * including session selection, loading state, and error handling
+ */
+export function TeleportResumeWrapper(t0) {
+    const $ = _c(25);
+    const { onComplete, onCancel, onError, isEmbedded: t1, source } = t0;
+    const isEmbedded = t1 === undefined ? false : t1;
+    const { resumeSession, isResuming, error, selectedSession } = useTeleportResume(source);
+    let t2;
+    let t3;
+    if ($[0] !== source) {
+        t2 = () => {
+            logEvent("tengu_teleport_started", {
+                source: source
+            });
+        };
+        t3 = [source];
+        $[0] = source;
+        $[1] = t2;
+        $[2] = t3;
+    }
+    else {
+        t2 = $[1];
+        t3 = $[2];
+    }
+    useEffect(t2, t3);
+    let t4;
+    if ($[3] !== error || $[4] !== onComplete || $[5] !== onError || $[6] !== resumeSession) {
+        t4 = async (session) => {
+            const result = await resumeSession(session);
+            if (result) {
+                onComplete(result);
+            }
+            else {
+                if (error) {
+                    if (onError) {
+                        onError(error.message, error.formattedMessage);
+                    }
+                }
+            }
+        };
+        $[3] = error;
+        $[4] = onComplete;
+        $[5] = onError;
+        $[6] = resumeSession;
+        $[7] = t4;
+    }
+    else {
+        t4 = $[7];
+    }
+    const handleSelect = t4;
+    let t5;
+    if ($[8] !== onCancel) {
+        t5 = () => {
+            logEvent("tengu_teleport_cancelled", {});
+            onCancel();
+        };
+        $[8] = onCancel;
+        $[9] = t5;
+    }
+    else {
+        t5 = $[9];
+    }
+    const handleCancel = t5;
+    const t6 = !!error && !onError;
+    let t7;
+    if ($[10] !== t6) {
+        t7 = {
+            context: "Global",
+            isActive: t6
+        };
+        $[10] = t6;
+        $[11] = t7;
+    }
+    else {
+        t7 = $[11];
+    }
+    useKeybinding("app:interrupt", handleCancel, t7);
+    if (isResuming && selectedSession) {
+        let t8;
+        if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+            t8 = _jsxs(Box, { flexDirection: "row", children: [_jsx(Spinner, {}), _jsx(Text, { bold: true, children: "Resuming session\u2026" })] });
+            $[12] = t8;
+        }
+        else {
+            t8 = $[12];
+        }
+        let t9;
+        if ($[13] !== selectedSession.title) {
+            t9 = _jsxs(Box, { flexDirection: "column", padding: 1, children: [t8, _jsxs(Text, { dimColor: true, children: ["Loading \"", selectedSession.title, "\"\u2026"] })] });
+            $[13] = selectedSession.title;
+            $[14] = t9;
+        }
+        else {
+            t9 = $[14];
+        }
+        return t9;
+    }
+    if (error && !onError) {
+        let t8;
+        if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
+            t8 = _jsx(Text, { bold: true, color: "error", children: "Failed to resume session" });
+            $[15] = t8;
+        }
+        else {
+            t8 = $[15];
+        }
+        let t9;
+        if ($[16] !== error.message) {
+            t9 = _jsx(Text, { dimColor: true, children: error.message });
+            $[16] = error.message;
+            $[17] = t9;
+        }
+        else {
+            t9 = $[17];
+        }
+        let t10;
+        if ($[18] === Symbol.for("react.memo_cache_sentinel")) {
+            t10 = _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", _jsx(Text, { bold: true, children: "Esc" }), " to cancel"] }) });
+            $[18] = t10;
+        }
+        else {
+            t10 = $[18];
+        }
+        let t11;
+        if ($[19] !== t9) {
+            t11 = _jsxs(Box, { flexDirection: "column", padding: 1, children: [t8, t9, t10] });
+            $[19] = t9;
+            $[20] = t11;
+        }
+        else {
+            t11 = $[20];
+        }
+        return t11;
+    }
+    let t8;
+    if ($[21] !== handleCancel || $[22] !== handleSelect || $[23] !== isEmbedded) {
+        t8 = _jsx(ResumeTask, { onSelect: handleSelect, onCancel: handleCancel, isEmbedded: isEmbedded });
+        $[21] = handleCancel;
+        $[22] = handleSelect;
+        $[23] = isEmbedded;
+        $[24] = t8;
+    }
+    else {
+        t8 = $[24];
+    }
+    return t8;
+}