@phuetz/code-buddy 0.1.0 → 0.1.1

package/dist/scripting/types.d.ts

@@ -1,241 +1,269 @@
 /**
- * Buddy Script Types
+ * Unified Script Types
  *
- * Type definitions for the Buddy Script language (.bs files)
- * Inspired by FileCommander Script (FCS)
+ * Merged from FileCommander Script (FCS) and Buddy Script
+ * FCS lexer/parser types as the superset, plus Buddy Script runtime types
+ *
+ * Extensions: .bs (primary), .fcs (backward-compatible alias)
  */
 export declare enum TokenType {
-    NUMBER = "NUMBER",
-    STRING = "STRING",
-    BOOLEAN = "BOOLEAN",
-    NULL = "NULL",
-    IDENTIFIER = "IDENTIFIER",
-    LET = "LET",
-    CONST = "CONST",
-    FUNCTION = "FUNCTION",
-    RETURN = "RETURN",
-    IF = "IF",
-    ELSE = "ELSE",
-    WHILE = "WHILE",
-    FOR = "FOR",
-    IN = "IN",
-    BREAK = "BREAK",
-    CONTINUE = "CONTINUE",
-    TRY = "TRY",
-    CATCH = "CATCH",
-    THROW = "THROW",
-    IMPORT = "IMPORT",
-    EXPORT = "EXPORT",
-    ASYNC = "ASYNC",
-    AWAIT = "AWAIT",
-    PLUS = "PLUS",
-    MINUS = "MINUS",
-    MULTIPLY = "MULTIPLY",
-    DIVIDE = "DIVIDE",
-    MODULO = "MODULO",
-    POWER = "POWER",
-    ASSIGN = "ASSIGN",
-    PLUS_ASSIGN = "PLUS_ASSIGN",
-    MINUS_ASSIGN = "MINUS_ASSIGN",
-    EQUALS = "EQUALS",
-    NOT_EQUALS = "NOT_EQUALS",
-    LESS_THAN = "LESS_THAN",
-    GREATER_THAN = "GREATER_THAN",
-    LESS_EQUAL = "LESS_EQUAL",
-    GREATER_EQUAL = "GREATER_EQUAL",
-    AND = "AND",
-    OR = "OR",
-    NOT = "NOT",
-    LPAREN = "LPAREN",
-    RPAREN = "RPAREN",
-    LBRACE = "LBRACE",
-    RBRACE = "RBRACE",
-    LBRACKET = "LBRACKET",
-    RBRACKET = "RBRACKET",
-    COMMA = "COMMA",
-    DOT = "DOT",
-    COLON = "COLON",
-    SEMICOLON = "SEMICOLON",
-    ARROW = "ARROW",
-    QUESTION = "QUESTION",
-    COMMENT = "COMMENT",
-    NEWLINE = "NEWLINE",
-    EOF = "EOF"
+    Number = "Number",
+    String = "String",
+    Boolean = "Boolean",
+    Null = "Null",
+    Regex = "Regex",
+    Identifier = "Identifier",
+    Keyword = "Keyword",
+    Plus = "Plus",// +
+    Minus = "Minus",// -
+    Multiply = "Multiply",// *
+    Divide = "Divide",// /
+    Modulo = "Modulo",// %
+    Power = "Power",// **
+    Equal = "Equal",// ==
+    NotEqual = "NotEqual",// !=
+    Less = "Less",// <
+    Greater = "Greater",// >
+    LessEqual = "LessEqual",// <=
+    GreaterEqual = "GreaterEqual",// >=
+    And = "And",// &&
+    Or = "Or",// ||
+    Not = "Not",// !
+    Assign = "Assign",// =
+    PlusAssign = "PlusAssign",// +=
+    MinusAssign = "MinusAssign",// -=
+    MultiplyAssign = "MultiplyAssign",// *=
+    DivideAssign = "DivideAssign",// /=
+    LeftParen = "LeftParen",// (
+    RightParen = "RightParen",// )
+    LeftBrace = "LeftBrace",// {
+    RightBrace = "RightBrace",// }
+    LeftBracket = "LeftBracket",// [
+    RightBracket = "RightBracket",// ]
+    Semicolon = "Semicolon",// ;
+    Comma = "Comma",// ,
+    Dot = "Dot",// .
+    Colon = "Colon",// :
+    Question = "Question",// ? (from Buddy Script - separate from Colon)
+    Arrow = "Arrow",// =>
+    Pipeline = "Pipeline",// |>
+    Comment = "Comment",
+    Newline = "Newline",
+    Indent = "Indent",
+    Dedent = "Dedent",
+    EOF = "EOF",
+    Decorator = "Decorator"
 }
 export interface Token {
     type: TokenType;
-    value: string | number | boolean | null;
+    value: string;
     line: number;
     column: number;
+    position: number;
+    length: number;
+}
+export declare const FCS_KEYWORDS: Set<string>;
+export interface AstNode {
+    type: string;
+    line?: number;
+    column?: number;
 }
-export type ASTNode = ProgramNode | StatementNode | ExpressionNode;
-export interface ProgramNode {
+export interface Program extends AstNode {
     type: 'Program';
-    body: StatementNode[];
+    statements: AstNode[];
+    /** @deprecated Use statements instead */
+    body?: AstNode[];
+}
+export interface LiteralExpr extends AstNode {
+    type: 'Literal';
+    value: unknown;
+    tokenType: TokenType;
+}
+export interface IdentifierExpr extends AstNode {
+    type: 'Identifier';
+    name: string;
+}
+export interface BinaryExpr extends AstNode {
+    type: 'Binary';
+    left: AstNode;
+    operator: TokenType;
+    right: AstNode;
+}
+export interface UnaryExpr extends AstNode {
+    type: 'Unary';
+    operator: TokenType;
+    operand: AstNode;
+}
+export interface AssignmentExpr extends AstNode {
+    type: 'Assignment';
+    target: AstNode;
+    operator: TokenType;
+    value: AstNode;
+}
+export interface CallExpr extends AstNode {
+    type: 'Call';
+    callee: AstNode;
+    arguments: AstNode[];
+    namedArgs?: Record<string, AstNode>;
+}
+export interface MemberExpr extends AstNode {
+    type: 'Member';
+    object: AstNode;
+    member: string;
+    computed: boolean;
 }
-export type StatementNode = VariableDeclaration | FunctionDeclaration | ExpressionStatement | IfStatement | WhileStatement | ForStatement | ForInStatement | ReturnStatement | BreakStatement | ContinueStatement | TryStatement | ThrowStatement | ImportStatement | BlockStatement;
-export interface VariableDeclaration {
-    type: 'VariableDeclaration';
-    kind: 'let' | 'const';
+export interface IndexExpr extends AstNode {
+    type: 'Index';
+    object: AstNode;
+    index: AstNode;
+}
+export interface ArrayExpr extends AstNode {
+    type: 'Array';
+    elements: AstNode[];
+}
+export interface DictExpr extends AstNode {
+    type: 'Dict';
+    elements: Map<string, AstNode>;
+}
+export interface LambdaExpr extends AstNode {
+    type: 'Lambda';
+    parameters: string[];
+    body: AstNode;
+}
+export interface InterpolationExpr extends AstNode {
+    type: 'Interpolation';
+    parts: AstNode[];
+}
+export interface PipelineExpr extends AstNode {
+    type: 'Pipeline';
+    left: AstNode;
+    right: AstNode;
+}
+export interface TernaryExpr extends AstNode {
+    type: 'Ternary';
+    condition: AstNode;
+    consequent: AstNode;
+    alternate: AstNode;
+}
+export interface AwaitExpr extends AstNode {
+    type: 'Await';
+    argument: AstNode;
+}
+export interface BlockStmt extends AstNode {
+    type: 'Block';
+    statements: AstNode[];
+}
+export interface ExpressionStmt extends AstNode {
+    type: 'ExpressionStmt';
+    expression: AstNode;
+}
+export interface VarDeclaration extends AstNode {
+    type: 'VarDeclaration';
     name: string;
-    init: ExpressionNode | null;
+    initializer: AstNode | null;
+    isConst: boolean;
+    varType?: string;
 }
-export interface FunctionDeclaration {
+export interface FunctionDeclaration extends AstNode {
     type: 'FunctionDeclaration';
     name: string;
-    params: ParameterNode[];
-    body: BlockStatement;
-    async: boolean;
+    parameters: Parameter[];
+    body: BlockStmt;
+    isAsync: boolean;
+    returnType?: string;
 }
-export interface ParameterNode {
+export interface Parameter {
     name: string;
-    defaultValue?: ExpressionNode;
-}
-export interface ExpressionStatement {
-    type: 'ExpressionStatement';
-    expression: ExpressionNode;
-}
-export interface IfStatement {
-    type: 'IfStatement';
-    condition: ExpressionNode;
-    consequent: BlockStatement;
-    alternate: BlockStatement | IfStatement | null;
-}
-export interface WhileStatement {
-    type: 'WhileStatement';
-    condition: ExpressionNode;
-    body: BlockStatement;
-}
-export interface ForStatement {
-    type: 'ForStatement';
-    init: VariableDeclaration | ExpressionNode | null;
-    test: ExpressionNode | null;
-    update: ExpressionNode | null;
-    body: BlockStatement;
-}
-export interface ForInStatement {
-    type: 'ForInStatement';
+    type?: string;
+    defaultValue?: AstNode;
+}
+export interface ClassDeclaration extends AstNode {
+    type: 'ClassDeclaration';
+    name: string;
+    baseClass?: string;
+    members: AstNode[];
+}
+export interface IfStmt extends AstNode {
+    type: 'If';
+    condition: AstNode;
+    thenBranch: AstNode;
+    elseBranch: AstNode | null;
+}
+export interface WhileStmt extends AstNode {
+    type: 'While';
+    condition: AstNode;
+    body: AstNode;
+}
+export interface ForStmt extends AstNode {
+    type: 'For';
     variable: string;
-    iterable: ExpressionNode;
-    body: BlockStatement;
+    iterable: AstNode;
+    body: AstNode;
+}
+export interface ForCStyleStmt extends AstNode {
+    type: 'ForCStyle';
+    init: AstNode | null;
+    test: AstNode | null;
+    update: AstNode | null;
+    body: AstNode;
 }
-export interface ReturnStatement {
-    type: 'ReturnStatement';
-    argument: ExpressionNode | null;
+export interface ReturnStmt extends AstNode {
+    type: 'Return';
+    value: AstNode | null;
 }
-export interface BreakStatement {
-    type: 'BreakStatement';
+export interface BreakStmt extends AstNode {
+    type: 'Break';
 }
-export interface ContinueStatement {
-    type: 'ContinueStatement';
+export interface ContinueStmt extends AstNode {
+    type: 'Continue';
 }
-export interface TryStatement {
-    type: 'TryStatement';
-    block: BlockStatement;
-    handler: CatchClause | null;
+export interface TryStmt extends AstNode {
+    type: 'Try';
+    tryBlock: BlockStmt;
+    catchClauses: CatchClause[];
+    finallyBlock: BlockStmt | null;
 }
 export interface CatchClause {
-    param: string;
-    body: BlockStatement;
+    variable?: string;
+    type?: string;
+    body: BlockStmt;
 }
-export interface ThrowStatement {
-    type: 'ThrowStatement';
-    argument: ExpressionNode;
+export interface ThrowStmt extends AstNode {
+    type: 'Throw';
+    expression: AstNode;
 }
-export interface ImportStatement {
-    type: 'ImportStatement';
+export interface ImportStmt extends AstNode {
+    type: 'Import';
     module: string;
+    names: string[];
     alias?: string;
 }
-export interface BlockStatement {
-    type: 'BlockStatement';
-    body: StatementNode[];
+export interface ExportStmt extends AstNode {
+    type: 'Export';
+    declaration: AstNode;
 }
-export type ExpressionNode = Literal | Identifier | BinaryExpression | UnaryExpression | LogicalExpression | AssignmentExpression | CallExpression | MemberExpression | ArrayExpression | ObjectExpression | ConditionalExpression | ArrowFunction | AwaitExpression | TemplateLiteral;
-export interface Literal {
-    type: 'Literal';
-    value: string | number | boolean | null;
-}
-export interface Identifier {
-    type: 'Identifier';
+export interface TestDeclaration extends AstNode {
+    type: 'TestDeclaration';
     name: string;
+    body: BlockStmt;
+    tags: string[];
 }
-export interface BinaryExpression {
-    type: 'BinaryExpression';
-    operator: string;
-    left: ExpressionNode;
-    right: ExpressionNode;
-}
-export interface UnaryExpression {
-    type: 'UnaryExpression';
-    operator: string;
-    argument: ExpressionNode;
-    prefix: boolean;
-}
-export interface LogicalExpression {
-    type: 'LogicalExpression';
-    operator: '&&' | '||';
-    left: ExpressionNode;
-    right: ExpressionNode;
-}
-export interface AssignmentExpression {
-    type: 'AssignmentExpression';
-    operator: string;
-    left: Identifier | MemberExpression;
-    right: ExpressionNode;
-}
-export interface CallExpression {
-    type: 'CallExpression';
-    callee: ExpressionNode;
-    arguments: ExpressionNode[];
-}
-export interface MemberExpression {
-    type: 'MemberExpression';
-    object: ExpressionNode;
-    property: ExpressionNode;
-    computed: boolean;
-}
-export interface ArrayExpression {
-    type: 'ArrayExpression';
-    elements: ExpressionNode[];
-}
-export interface ObjectExpression {
-    type: 'ObjectExpression';
-    properties: PropertyNode[];
-}
-export interface PropertyNode {
-    key: string | ExpressionNode;
-    value: ExpressionNode;
-    computed: boolean;
-}
-export interface ConditionalExpression {
-    type: 'ConditionalExpression';
-    test: ExpressionNode;
-    consequent: ExpressionNode;
-    alternate: ExpressionNode;
-}
-export interface ArrowFunction {
-    type: 'ArrowFunction';
-    params: ParameterNode[];
-    body: ExpressionNode | BlockStatement;
-    async: boolean;
-}
-export interface AwaitExpression {
-    type: 'AwaitExpression';
-    argument: ExpressionNode;
+export interface AssertStmt extends AstNode {
+    type: 'Assert';
+    condition: AstNode;
+    message?: string;
 }
-export interface TemplateLiteral {
-    type: 'TemplateLiteral';
-    parts: (string | ExpressionNode)[];
+export interface EditorCommand extends AstNode {
+    type: 'EditorCommand';
+    command: string;
+    arguments: AstNode[];
 }
 /**
- * Primitive types that can be stored in scripting variables
+ * Primitive types that can be stored in script variables
  */
 export type CodeBuddyPrimitive = string | number | boolean | null | undefined;
 /**
  * Function type for the scripting runtime.
- * Note: Uses flexible typing to support dynamic scripting scenarios.
- * Implementations should validate arguments at runtime.
  */
 export type CodeBuddyFunction = (...args: CodeBuddyValue[]) => CodeBuddyValue | Promise<CodeBuddyValue> | any;
 /**
@@ -250,7 +278,6 @@ export type CodeBuddyObject = {
 export type CodeBuddyArray = CodeBuddyValue[];
 /**
  * Dynamic value type for the scripting runtime.
- * Uses a union of known types for better type safety.
  */
 export type CodeBuddyValue = CodeBuddyPrimitive | CodeBuddyFunction | CodeBuddyObject | CodeBuddyArray | any;
 /**
@@ -268,6 +295,11 @@ export interface ScriptResult {
     error?: string;
     returnValue?: CodeBuddyValue;
     duration: number;
+    testResults?: {
+        name: string;
+        passed: boolean;
+        error?: string;
+    }[];
 }
 /** Interface for AI agent used by scripts */
 export interface ScriptAgentInterface {
@@ -296,3 +328,69 @@ export interface CodeBuddyScriptConfig {
     agent?: ScriptAgentInterface;
 }
 export declare const DEFAULT_SCRIPT_CONFIG: CodeBuddyScriptConfig;
+/** @deprecated Use CodeBuddyScriptConfig instead */
+export type FCSConfig = CodeBuddyScriptConfig;
+/** @deprecated Use CodeBuddyValue instead */
+export type FCSValue = CodeBuddyValue;
+/** @deprecated Use CodeBuddyFunction instead */
+export type FCSFunction = CodeBuddyFunction;
+/** @deprecated Use CodeBuddyPrimitive instead */
+export type FCSPrimitive = CodeBuddyPrimitive;
+/** @deprecated Use CodeBuddyObject instead */
+export type FCSObject = CodeBuddyObject;
+/** @deprecated Use CodeBuddyArray instead */
+export type FCSArray = CodeBuddyArray;
+/** @deprecated Use RuntimeContext instead */
+export type FCSContext = RuntimeContext;
+/** @deprecated Use ScriptResult instead */
+export type FCSResult = ScriptResult;
+/** @deprecated Use DEFAULT_SCRIPT_CONFIG instead */
+export declare const DEFAULT_FCS_CONFIG: CodeBuddyScriptConfig;
+/** @deprecated Use Program instead */
+export type ProgramNode = Program;
+/** @deprecated Use BlockStmt instead */
+export type BlockStatement = BlockStmt;
+/** @deprecated Use VarDeclaration instead */
+export type VariableDeclaration = VarDeclaration;
+/** @deprecated Use IfStmt instead */
+export type IfStatement = IfStmt;
+/** @deprecated Use WhileStmt instead */
+export type WhileStatement = WhileStmt;
+/** @deprecated Use ForStmt instead */
+export type ForStatement = ForStmt;
+/** @deprecated Use ForStmt instead */
+export type ForInStatement = ForStmt;
+/** @deprecated Use ReturnStmt instead */
+export type ReturnStatement = ReturnStmt;
+/** @deprecated Use TryStmt instead */
+export type TryStatement = TryStmt;
+/** @deprecated Use ThrowStmt instead */
+export type ThrowStatement = ThrowStmt;
+/** @deprecated Use ExpressionStmt instead */
+export type ExpressionStatement = ExpressionStmt;
+/** @deprecated Use LiteralExpr instead */
+export type Literal = LiteralExpr;
+/** @deprecated Use IdentifierExpr instead */
+export type Identifier = IdentifierExpr;
+/** @deprecated Use BinaryExpr instead */
+export type BinaryExpression = BinaryExpr;
+/** @deprecated Use UnaryExpr instead */
+export type UnaryExpression = UnaryExpr;
+/** @deprecated Use AssignmentExpr instead */
+export type AssignmentExpression = AssignmentExpr;
+/** @deprecated Use CallExpr instead */
+export type CallExpression = CallExpr;
+/** @deprecated Use MemberExpr instead */
+export type MemberExpression = MemberExpr;
+/** @deprecated Use ArrayExpr instead */
+export type ArrayExpression = ArrayExpr;
+/** @deprecated Use DictExpr instead */
+export type ObjectExpression = DictExpr;
+/** @deprecated Use TernaryExpr instead */
+export type ConditionalExpression = TernaryExpr;
+/** @deprecated Use LambdaExpr instead */
+export type ArrowFunction = LambdaExpr;
+/** @deprecated Use AssignmentExpr instead */
+export type LogicalExpression = AssignmentExpr;
+/** @deprecated Use AwaitExpr instead */
+export type AwaitExpression = AwaitExpr;