@terminals-tech/py2bend 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,236 @@
+/** Python AST node types we support (Phase 1 subset) */
+type PyNodeType = "Module" | "FunctionDef" | "Return" | "Assign" | "AugAssign" | "If" | "For" | "While" | "Expr" | "BinOp" | "UnaryOp" | "Compare" | "BoolOp" | "Call" | "Name" | "Constant" | "Attribute" | "Subscript" | "List" | "Dict" | "Lambda" | "ClassDef" | "Try";
+interface PyNode {
+    type: PyNodeType;
+    [key: string]: unknown;
+}
+interface PyModule extends PyNode {
+    type: "Module";
+    body: PyNode[];
+}
+interface PyFunctionDef extends PyNode {
+    type: "FunctionDef";
+    name: string;
+    params: string[];
+    body: PyNode[];
+    decorators: string[];
+}
+interface PyReturn extends PyNode {
+    type: "Return";
+    value: PyNode | null;
+}
+interface PyAssign extends PyNode {
+    type: "Assign";
+    target: string;
+    value: PyNode;
+}
+interface PyAugAssign extends PyNode {
+    type: "AugAssign";
+    target: string;
+    op: string;
+    value: PyNode;
+}
+interface PyIf extends PyNode {
+    type: "If";
+    test: PyNode;
+    body: PyNode[];
+    orelse: PyNode[];
+}
+interface PyFor extends PyNode {
+    type: "For";
+    target: string;
+    iter: PyNode;
+    body: PyNode[];
+}
+interface PyWhile extends PyNode {
+    type: "While";
+    test: PyNode;
+    body: PyNode[];
+}
+interface PyExpr extends PyNode {
+    type: "Expr";
+    value: PyNode;
+}
+interface PyBinOp extends PyNode {
+    type: "BinOp";
+    left: PyNode;
+    op: string;
+    right: PyNode;
+}
+interface PyUnaryOp extends PyNode {
+    type: "UnaryOp";
+    op: string;
+    operand: PyNode;
+}
+interface PyCompare extends PyNode {
+    type: "Compare";
+    left: PyNode;
+    ops: string[];
+    comparators: PyNode[];
+}
+interface PyBoolOp extends PyNode {
+    type: "BoolOp";
+    op: "and" | "or";
+    values: PyNode[];
+}
+interface PyCall extends PyNode {
+    type: "Call";
+    func: PyNode;
+    args: PyNode[];
+    kwargs: Array<{
+        key: string;
+        value: PyNode;
+    }>;
+}
+interface PyName extends PyNode {
+    type: "Name";
+    id: string;
+}
+interface PyConstant extends PyNode {
+    type: "Constant";
+    value: string | number | boolean | null;
+    kind: "str" | "int" | "float" | "bool" | "none";
+}
+interface PyAttribute extends PyNode {
+    type: "Attribute";
+    value: PyNode;
+    attr: string;
+}
+interface PySubscript extends PyNode {
+    type: "Subscript";
+    value: PyNode;
+    slice: PyNode;
+}
+interface PyList extends PyNode {
+    type: "List";
+    elts: PyNode[];
+}
+interface PyDict extends PyNode {
+    type: "Dict";
+    keys: PyNode[];
+    values: PyNode[];
+}
+interface PyLambda extends PyNode {
+    type: "Lambda";
+    params: string[];
+    body: PyNode;
+}
+interface PyClassDef extends PyNode {
+    type: "ClassDef";
+    name: string;
+    bases: string[];
+    body: PyNode[];
+}
+interface PyTry extends PyNode {
+    type: "Try";
+    body: PyNode[];
+    handler: {
+        name: string | null;
+        type: string | null;
+        body: PyNode[];
+    } | null;
+}
+/** Compilation result */
+interface CompileResult {
+    bend: string;
+    errors: CompileError[];
+    warnings: string[];
+}
+interface CompileError {
+    message: string;
+    line?: number;
+    column?: number;
+    severity: "error" | "warning";
+}
+type BendNodeType = "BendModule" | "BendFunctionDef" | "BendFold" | "BendLoop" | "BendObject" | "BendWith" | "BendPassthrough";
+interface BendNode {
+    type: BendNodeType;
+    /** Original Python AST node this was derived from */
+    source: PyNodeType;
+    [key: string]: unknown;
+}
+/** Top-level Bend module */
+interface BendModule extends BendNode {
+    type: "BendModule";
+    source: "Module";
+    body: BendNode[];
+}
+/** Bend function definition — 1:1 from PyFunctionDef, body recursively transformed */
+interface BendFunctionDef extends BendNode {
+    type: "BendFunctionDef";
+    source: "FunctionDef";
+    name: string;
+    params: string[];
+    body: BendNode[];
+    decorators: string[];
+}
+/** for loop -> fold over list */
+interface BendFold extends BendNode {
+    type: "BendFold";
+    source: "For";
+    target: string;
+    iter: PyNode;
+    body: BendNode[];
+    accumulator: string | null;
+}
+/** while loop -> bend/fork recursive generation */
+interface BendLoop extends BendNode {
+    type: "BendLoop";
+    source: "While";
+    test: PyNode;
+    body: BendNode[];
+    stateVars: string[];
+}
+/** class -> Bend ADT (algebraic data type) */
+interface BendObject extends BendNode {
+    type: "BendObject";
+    source: "ClassDef";
+    name: string;
+    bases: string[];
+    fields: string[];
+    methods: BendFunctionDef[];
+}
+/** try/except -> with Result: monadic error handling */
+interface BendWith extends BendNode {
+    type: "BendWith";
+    source: "Try";
+    body: BendNode[];
+    handler: {
+        name: string | null;
+        type: string | null;
+        body: BendNode[];
+    } | null;
+}
+/** Passthrough — nodes that don't need structural transformation */
+interface BendPassthrough extends BendNode {
+    type: "BendPassthrough";
+    node: PyNode;
+}
+/** Parser result */
+interface ParseResult {
+    ast: PyModule | null;
+    errors: CompileError[];
+}
+
+declare function parsePython(source: string): ParseResult;
+
+/** Transform a parsed Python module AST into Bend IR */
+declare function transformModule(ast: PyModule): BendModule;
+
+/** Generate Bend source code from a BendModule IR */
+declare function generateBend(module: BendModule): string;
+
+/** Python builtin functions -> Bend stdlib equivalents */
+declare const BUILTIN_MAP: Record<string, string>;
+/** Python binary/unary/boolean operators -> Bend operators */
+declare const OP_MAP: Record<string, string>;
+/** Python method calls -> Bend function equivalents */
+declare const METHOD_MAP: Record<string, string>;
+
+/**
+ * Compile Python source to Bend source code.
+ * Chains: parse -> transform -> generate
+ */
+declare function compile(pythonSource: string): CompileResult;
+
+export { BUILTIN_MAP, type BendFold, type BendFunctionDef, type BendLoop, type BendModule, type BendNode, type BendObject, type BendPassthrough, type BendWith, type CompileError, type CompileResult, METHOD_MAP, OP_MAP, type ParseResult, type PyAssign, type PyAttribute, type PyAugAssign, type PyBinOp, type PyBoolOp, type PyCall, type PyClassDef, type PyCompare, type PyConstant, type PyDict, type PyExpr, type PyFor, type PyFunctionDef, type PyIf, type PyLambda, type PyList, type PyModule, type PyName, type PyNode, type PyReturn, type PySubscript, type PyTry, type PyUnaryOp, type PyWhile, compile, generateBend, parsePython, transformModule };