@aria-cli/cli 1.0.50 → 1.0.51

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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,10 @@
+// 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

@@ -0,0 +1,68 @@
+// 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

@@ -0,0 +1,10 @@
+// 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

@@ -0,0 +1,326 @@
+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