@aria-cli/cli 1.0.57 → 1.0.58

package/dist/ui/components/permissions/PermissionRequest.js

@@ -1,70 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-// Changes:
-// - Tool import → minimal ToolLike interface
-// - Removed tool object references (FileEditTool, BashTool, etc.) → name-based dispatch
-// - Removed PRODUCT_NAME → "ARIA"
-// - Removed useNotifyAfterTimeout (analytics/notification)
-// - Removed AssistantMessage import → inline type
-// - Removed CommandSubcommandPrefixResult → inline type
-import { useInput } from "ink";
-import * as React from "react";
-import { isEscapeInput } from "../../utils/keys.js";
-import { FileEditPermissionRequest } from "./FileEditPermissionRequest/FileEditPermissionRequest.js";
-import { BashPermissionRequest } from "./BashPermissionRequest/BashPermissionRequest.js";
-import { FallbackPermissionRequest } from "./FallbackPermissionRequest.js";
-import { FileWritePermissionRequest } from "./FileWritePermissionRequest/FileWritePermissionRequest.js";
-import { FilesystemPermissionRequest } from "./FilesystemPermissionRequest/FilesystemPermissionRequest.js";
-// Name-based routing for tool-specific permission components
-const FILE_EDIT_TOOLS = new Set(["Edit", "file_edit", "str_replace_editor"]);
-const FILE_WRITE_TOOLS = new Set(["Write", "file_write", "create_file"]);
-const BASH_TOOLS = new Set(["Bash", "bash", "execute_command"]);
-const FILESYSTEM_TOOLS = new Set([
-    "Glob",
-    "glob",
-    "Grep",
-    "grep",
-    "LS",
-    "ls",
-    "Read",
-    "file_read",
-    "read_file",
-    "NotebookRead",
-    "notebook_read",
-    "NotebookEdit",
-    "notebook_edit",
-]);
-function permissionComponentForToolName(name) {
-    if (FILE_EDIT_TOOLS.has(name))
-        return FileEditPermissionRequest;
-    if (FILE_WRITE_TOOLS.has(name))
-        return FileWritePermissionRequest;
-    if (BASH_TOOLS.has(name))
-        return BashPermissionRequest;
-    if (FILESYSTEM_TOOLS.has(name))
-        return FilesystemPermissionRequest;
-    return FallbackPermissionRequest;
-}
-export function toolUseConfirmGetPrefix(toolUseConfirm) {
-    return ((toolUseConfirm.commandPrefix &&
-        !toolUseConfirm.commandPrefix.commandInjectionDetected &&
-        toolUseConfirm.commandPrefix.commandPrefix) ||
-        null);
-}
-export function PermissionRequest({ toolUseConfirm, onDone, verbose, }) {
-    const dismissedRef = React.useRef(false);
-    // Handle Ctrl+C and Escape — reject and close the modal.
-    // Guard with dismissedRef so rapid keypresses don't double-fire
-    // onReject/onDone before React unmounts the component.
-    useInput((input, key) => {
-        if (dismissedRef.current)
-            return;
-        if ((key.ctrl && input === "c") || isEscapeInput(input, key)) {
-            dismissedRef.current = true;
-            toolUseConfirm.onReject();
-            onDone();
-        }
-    });
-    const PermissionComponent = permissionComponentForToolName(toolUseConfirm.tool.name);
-    return _jsx(PermissionComponent, { toolUseConfirm: toolUseConfirm, onDone: onDone, verbose: verbose });
-}
-//# sourceMappingURL=PermissionRequest.js.map

package/dist/ui/components/permissions/PermissionRequestTitle.js

@@ -1,41 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-import { getTheme } from "../../theme/index.js";
-export function categoryForRiskScore(riskScore) {
-    return riskScore >= 70 ? "high" : riskScore >= 30 ? "moderate" : "low";
-}
-function colorSchemeForRiskScoreCategory(category) {
-    const theme = getTheme();
-    switch (category) {
-        case "low":
-            return {
-                highlightColor: theme.colors.success,
-                textColor: theme.colors.primary,
-            };
-        case "moderate":
-            return {
-                highlightColor: theme.colors.warning,
-                textColor: theme.colors.warning,
-            };
-        case "high":
-            return {
-                highlightColor: theme.colors.error,
-                textColor: theme.colors.error,
-            };
-    }
-}
-export function textColorForRiskScore(riskScore) {
-    if (riskScore === null) {
-        return getTheme().colors.primary;
-    }
-    const category = categoryForRiskScore(riskScore);
-    return colorSchemeForRiskScoreCategory(category).textColor;
-}
-export function PermissionRiskScore({ riskScore }) {
-    const category = categoryForRiskScore(riskScore);
-    return _jsxs(Text, { color: textColorForRiskScore(riskScore), children: ["Risk: ", category] });
-}
-export function PermissionRequestTitle({ title, riskScore }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: getTheme().colors.primary, children: title }), riskScore !== null && _jsx(PermissionRiskScore, { riskScore: riskScore })] }));
-}
-//# sourceMappingURL=PermissionRequestTitle.js.map

package/dist/ui/components/permissions/hooks.js

@@ -1,10 +0,0 @@
-// Change: removed all analytics (usePermissionRequestLogging was Statsig + unary logging)
-// This hook is now a no-op stub kept for structural compatibility.
-/**
- * Stub for usePermissionRequestLogging.
- * Analytics removed.
- */
-export function usePermissionRequestLogging(_toolUseConfirm, _unaryEvent) {
-    // no-op: analytics removed
-}
-//# sourceMappingURL=hooks.js.map

package/dist/ui/components/permissions/toolUseOptions.js

@@ -1,68 +0,0 @@
-// Changes:
-// - Option type from @inkjs/ui → imported from CustomSelect
-// - isUnsafeCompoundCommand → inline stub (always false)
-// - getCwd → process.cwd()
-// - getTheme → ARIA's theme
-import chalk from "chalk";
-import { toolUseConfirmGetPrefix } from "./PermissionRequest.js";
-import { getTheme } from "../../theme/index.js";
-/**
- * Detects compound shell commands that chain multiple operations.
- * Returns true if the command contains shell operators that could execute
- * additional commands beyond what was explicitly approved.
- */
-function isUnsafeCompoundCommand(command) {
-    // Strip content inside single-quoted strings (they don't expand)
-    const withoutSingleQuoted = command.replace(/'[^']*'/g, "");
-    // Strip content inside double-quoted strings (preserve operators outside quotes)
-    const withoutQuoted = withoutSingleQuoted.replace(/"[^"]*"/g, "");
-    // Check for shell compound operators: &&, ||, ;, |, backticks, $()
-    if (/&&|\|\||[;|]/.test(withoutQuoted))
-        return true;
-    if (/`/.test(withoutQuoted))
-        return true;
-    if (/\$\(/.test(withoutQuoted))
-        return true;
-    return false;
-}
-/**
- * Generates options for the tool use confirmation dialog
- */
-export function toolUseOptions({ toolUseConfirm, command, }) {
-    // Hide "don't ask again" options if the command is an unsafe compound command, or a potential command injection
-    const showDontAskAgainOption = !isUnsafeCompoundCommand(command) &&
-        toolUseConfirm.commandPrefix &&
-        !toolUseConfirm.commandPrefix.commandInjectionDetected;
-    const prefix = toolUseConfirmGetPrefix(toolUseConfirm);
-    const showDontAskAgainPrefixOption = showDontAskAgainOption && prefix !== null;
-    let dontShowAgainOptions = [];
-    if (showDontAskAgainPrefixOption) {
-        // Prefix option takes precedence over full command option
-        dontShowAgainOptions = [
-            {
-                label: `Yes, and don't ask again for ${chalk.bold(prefix)} commands in ${chalk.bold(process.cwd())}`,
-                value: "yes-dont-ask-again-prefix",
-            },
-        ];
-    }
-    else if (showDontAskAgainOption) {
-        dontShowAgainOptions = [
-            {
-                label: `Yes, and don't ask again for ${chalk.bold(command)} commands in ${chalk.bold(process.cwd())}`,
-                value: "yes-dont-ask-again-full",
-            },
-        ];
-    }
-    return [
-        {
-            label: "Yes",
-            value: "yes",
-        },
-        ...dontShowAgainOptions,
-        {
-            label: `No, and provide instructions (${chalk.bold.hex(getTheme().colors.warning)("esc")})`,
-            value: "no",
-        },
-    ];
-}
-//# sourceMappingURL=toolUseOptions.js.map

package/dist/ui/components/permissions/utils.js

@@ -1,10 +0,0 @@
-// Change: removed logUnaryEvent and env imports (analytics removed)
-// This module is now a no-op stub kept for structural compatibility.
-/**
- * Stub for logUnaryPermissionEvent.
- * Analytics removed.
- */
-export function logUnaryPermissionEvent(_completion_type, _toolUseConfirm, _event) {
-    // no-op: analytics removed
-}
-//# sourceMappingURL=utils.js.map

package/dist/ui/components/text-input/Cursor.js

@@ -1,326 +0,0 @@
-import stringWidth from "string-width";
-export class Cursor {
-    measuredText;
-    selection;
-    offset;
-    constructor(measuredText, offset = 0, selection = 0) {
-        this.measuredText = measuredText;
-        this.selection = selection;
-        // it's ok for the cursor to be 1 char beyond the end of the string
-        this.offset = Math.max(0, Math.min(this.measuredText.text.length, offset));
-    }
-    static fromText(text, columns, offset = 0, selection = 0) {
-        // make MeasuredText on less than columns width, to account for cursor
-        return new Cursor(new MeasuredText(text, columns - 1), offset, selection);
-    }
-    render(cursorChar, mask, invert) {
-        const { line, column } = this.getPosition();
-        return this.measuredText
-            .getWrappedText()
-            .map((text, currentLine, allLines) => {
-            let displayText = text;
-            if (mask && currentLine === allLines.length - 1) {
-                const lastSixStart = Math.max(0, text.length - 6);
-                displayText = mask.repeat(lastSixStart) + text.slice(lastSixStart);
-            }
-            // looking for the line with the cursor
-            if (line != currentLine)
-                return displayText.trimEnd();
-            return (displayText.slice(0, column) +
-                invert(displayText[column] || cursorChar) +
-                displayText.trimEnd().slice(column + 1));
-        })
-            .join("\n");
-    }
-    left() {
-        return new Cursor(this.measuredText, this.offset - 1);
-    }
-    right() {
-        return new Cursor(this.measuredText, this.offset + 1);
-    }
-    up() {
-        const { line, column } = this.getPosition();
-        if (line == 0) {
-            return new Cursor(this.measuredText, 0, 0);
-        }
-        const newOffset = this.getOffset({ line: line - 1, column });
-        return new Cursor(this.measuredText, newOffset, 0);
-    }
-    down() {
-        const { line, column } = this.getPosition();
-        if (line >= this.measuredText.lineCount - 1) {
-            return new Cursor(this.measuredText, this.text.length, 0);
-        }
-        const newOffset = this.getOffset({ line: line + 1, column });
-        return new Cursor(this.measuredText, newOffset, 0);
-    }
-    startOfLine() {
-        const { line } = this.getPosition();
-        return new Cursor(this.measuredText, this.getOffset({
-            line,
-            column: 0,
-        }), 0);
-    }
-    endOfLine() {
-        const { line } = this.getPosition();
-        const column = this.measuredText.getLineLength(line);
-        const offset = this.getOffset({ line, column });
-        return new Cursor(this.measuredText, offset, 0);
-    }
-    nextWord() {
-        let nextCursor = this;
-        // If we're on a word, move to the next non-word
-        while (nextCursor.isOverWordChar() && !nextCursor.isAtEnd()) {
-            nextCursor = nextCursor.right();
-        }
-        // now move to the next word char
-        while (!nextCursor.isOverWordChar() && !nextCursor.isAtEnd()) {
-            nextCursor = nextCursor.right();
-        }
-        return nextCursor;
-    }
-    prevWord() {
-        let cursor = this;
-        // if we are already at the beginning of a word, step off it
-        if (!cursor.left().isOverWordChar()) {
-            cursor = cursor.left();
-        }
-        // Move left over any non-word characters
-        while (!cursor.isOverWordChar() && !cursor.isAtStart()) {
-            cursor = cursor.left();
-        }
-        // If we're over a word character, move to the start of this word
-        if (cursor.isOverWordChar()) {
-            while (cursor.left().isOverWordChar() && !cursor.isAtStart()) {
-                cursor = cursor.left();
-            }
-        }
-        return cursor;
-    }
-    modifyText(end, insertString = "") {
-        const startOffset = this.offset;
-        const endOffset = end.offset;
-        const newText = this.text.slice(0, startOffset) + insertString + this.text.slice(endOffset);
-        return Cursor.fromText(newText, this.columns, startOffset + insertString.length);
-    }
-    insert(insertString) {
-        const newCursor = this.modifyText(this, insertString);
-        return newCursor;
-    }
-    del() {
-        if (this.isAtEnd()) {
-            return this;
-        }
-        return this.modifyText(this.right());
-    }
-    backspace() {
-        if (this.isAtStart()) {
-            return this;
-        }
-        // Get the current position
-        const currentOffset = this.offset;
-        // Create a new cursor at the position before the current one
-        const leftCursor = this.left();
-        const leftOffset = leftCursor.offset;
-        // Create the new text by removing one character
-        const newText = this.text.slice(0, leftOffset) + this.text.slice(currentOffset);
-        // Return a new cursor with the updated text and position
-        return Cursor.fromText(newText, this.columns, leftOffset);
-    }
-    deleteToLineStart() {
-        return this.startOfLine().modifyText(this);
-    }
-    deleteToLineEnd() {
-        // If cursor is on a newline character, delete just that character
-        if (this.text[this.offset] === "\n") {
-            return this.modifyText(this.right());
-        }
-        return this.modifyText(this.endOfLine());
-    }
-    deleteWordBefore() {
-        if (this.isAtStart()) {
-            return this;
-        }
-        return this.prevWord().modifyText(this);
-    }
-    deleteWordAfter() {
-        if (this.isAtEnd()) {
-            return this;
-        }
-        return this.modifyText(this.nextWord());
-    }
-    isOverWordChar() {
-        const currentChar = this.text[this.offset] ?? "";
-        return /\w/.test(currentChar);
-    }
-    equals(other) {
-        return this.offset === other.offset && this.measuredText == other.measuredText;
-    }
-    isAtStart() {
-        return this.offset == 0;
-    }
-    isAtEnd() {
-        return this.offset == this.text.length;
-    }
-    get text() {
-        return this.measuredText.text;
-    }
-    get columns() {
-        return this.measuredText.columns + 1;
-    }
-    getPosition() {
-        return this.measuredText.getPositionFromOffset(this.offset);
-    }
-    getOffset(position) {
-        return this.measuredText.getOffsetFromPosition(position);
-    }
-}
-class WrappedLine {
-    text;
-    startOffset;
-    isPrecededByNewline;
-    endsWithNewline;
-    constructor(text, startOffset, isPrecededByNewline, endsWithNewline = false) {
-        this.text = text;
-        this.startOffset = startOffset;
-        this.isPrecededByNewline = isPrecededByNewline;
-        this.endsWithNewline = endsWithNewline;
-    }
-    equals(other) {
-        return this.text === other.text && this.startOffset === other.startOffset;
-    }
-    get length() {
-        return this.text.length + (this.endsWithNewline ? 1 : 0);
-    }
-}
-export class MeasuredText {
-    text;
-    columns;
-    wrappedLines;
-    constructor(text, columns) {
-        this.text = text;
-        this.columns = columns;
-        this.wrappedLines = this.measureWrappedText();
-    }
-    /**
-     * Walk the text character-by-character using stringWidth for visual widths,
-     * computing line breaks directly. This replaces the old wrapAnsi+indexOf
-     * approach which crashed when wrapAnsi transformed text (tab expansion,
-     * ANSI re-sequencing, wide-char padding) making indexOf fail.
-     */
-    measureWrappedText() {
-        if (this.text.length === 0) {
-            return [new WrappedLine("", 0, true, false)];
-        }
-        const lines = [];
-        let pos = 0;
-        while (pos < this.text.length) {
-            const lineStart = pos;
-            const isAfterNewline = pos === 0 || this.text[pos - 1] === "\n";
-            let width = 0;
-            let scan = pos;
-            let lastSpacePos = -1;
-            while (scan < this.text.length) {
-                const ch = this.text[scan];
-                if (ch === "\n") {
-                    lines.push(new WrappedLine(this.text.slice(lineStart, scan), lineStart, isAfterNewline, true));
-                    pos = scan + 1;
-                    break;
-                }
-                const cp = this.text.codePointAt(scan);
-                const fullChar = String.fromCodePoint(cp);
-                const charWidth = stringWidth(fullChar);
-                if (width + charWidth > this.columns) {
-                    let wrapPos;
-                    if (lastSpacePos >= lineStart && lastSpacePos + 1 < scan) {
-                        // Word wrap: break after the last space
-                        wrapPos = lastSpacePos + 1;
-                    }
-                    else if (scan > lineStart) {
-                        // Hard wrap: break before this character
-                        wrapPos = scan;
-                    }
-                    else {
-                        // Single character wider than columns — force it on this line
-                        wrapPos = scan + fullChar.length;
-                    }
-                    lines.push(new WrappedLine(this.text.slice(lineStart, wrapPos), lineStart, isAfterNewline, false));
-                    pos = wrapPos;
-                    break;
-                }
-                if (ch === " " || ch === "\t") {
-                    lastSpacePos = scan;
-                }
-                width += charWidth;
-                scan += fullChar.length;
-            }
-            // Reached end of text without hitting \n or wrap
-            if (scan >= this.text.length && pos === lineStart) {
-                lines.push(new WrappedLine(this.text.slice(lineStart), lineStart, isAfterNewline, false));
-                pos = this.text.length;
-            }
-        }
-        // Trailing newline produces an empty final line
-        if (this.text.length > 0 && this.text[this.text.length - 1] === "\n") {
-            lines.push(new WrappedLine("", this.text.length, true, false));
-        }
-        return lines;
-    }
-    getWrappedText() {
-        return this.wrappedLines.map((line) => line.isPrecededByNewline ? line.text : line.text.trimStart());
-    }
-    getLine(line) {
-        return this.wrappedLines[Math.max(0, Math.min(line, this.wrappedLines.length - 1))];
-    }
-    getOffsetFromPosition(position) {
-        const wrappedLine = this.getLine(position.line);
-        const startOffsetPlusColumn = wrappedLine.startOffset + position.column;
-        // Handle blank lines specially
-        if (wrappedLine.text.length === 0 && wrappedLine.endsWithNewline) {
-            return wrappedLine.startOffset;
-        }
-        // For normal lines
-        const lineEnd = wrappedLine.startOffset + wrappedLine.text.length;
-        // Add 1 only if this line ends with a newline
-        const maxOffset = wrappedLine.endsWithNewline ? lineEnd + 1 : lineEnd;
-        return Math.min(startOffsetPlusColumn, maxOffset);
-    }
-    getLineLength(line) {
-        const currentLine = this.getLine(line);
-        const nextLine = this.getLine(line + 1);
-        if (nextLine.equals(currentLine)) {
-            return this.text.length - currentLine.startOffset;
-        }
-        return nextLine.startOffset - currentLine.startOffset - 1;
-    }
-    getPositionFromOffset(offset) {
-        const lines = this.wrappedLines;
-        for (let line = 0; line < lines.length; line++) {
-            const currentLine = lines[line];
-            const nextLine = lines[line + 1];
-            if (offset >= currentLine.startOffset && (!nextLine || offset < nextLine.startOffset)) {
-                const leadingWhitepace = currentLine.isPrecededByNewline
-                    ? 0
-                    : currentLine.text.length - currentLine.text.trimStart().length;
-                const column = Math.max(0, Math.min(offset - currentLine.startOffset - leadingWhitepace, currentLine.text.length));
-                return {
-                    line,
-                    column,
-                };
-            }
-        }
-        // If we're past the last character, return the end of the last line
-        const line = lines.length - 1;
-        return {
-            line,
-            column: this.wrappedLines[line].text.length,
-        };
-    }
-    get lineCount() {
-        return this.wrappedLines.length;
-    }
-    equals(other) {
-        return this.text === other.text && this.columns === other.columns;
-    }
-}
-//# sourceMappingURL=Cursor.js.map