// 我的第一个易狗程序
函数 主函数() {
    打印("你好，易狗IDE！")
    变量 名字 := "道生易"
    打印("欢迎，" + 名字)
}

如果 (age >= 18) {
    打印("已成年")
} 否则 {
    打印("未成年")
}

判断循环 (i < 10) {
    打印(i)
    i = i + 1
}

选择 (day) {
情况 1: 打印("周一")
情况 2: 打印("周二")
默认: 打印("其他")
}

函数 计算阶乘(n 整数) 整数 {
    @嵌入
        if n <= 1 {
            return 1
        }
        return n * factorial(n-1)
    @结束
}

// 自定义类型（@嵌入 Go 原生 type 关键字）
@嵌入
    type UserID int
    type Score float64
@结束

函数 主函数() {
    变量 uid = 1001      // Go 自动推断为 int
    变量 sc  = 98.5       // Go 自动推断为 float64
    打印(uid, sc)
}

// 中文类型别名（与 Go 原生等价，编译期自动转译）
变量 年龄 整数 = 18
变量 分数 小数 = 95.5
变量 已婚 逻辑 = 真
变量 编号 []整数 = []整数{1, 2, 3}
函数 主函数() {
    打印(年龄, 分数, 已婚, 编号)
}

变量 a := 10
变量 b := 3
打印(a + b)            // 13
打印(a / b)            // 3（整数除法）
打印(a % b)            // 1

如果 (a > b 且 b != 0) {
    打印("条件成立")
}

a += 5                    // a 现在是 15

函数 主函数() {
    @嵌入
        var nums []int = []int{1, 2, 3}
        nums = append(nums, 4, 5)
        fmt.Println("len=", len(nums), "cap=", cap(nums))
        for i, v range nums {
            fmt.Printf("nums[%d]=%d\n", i, v)
        }
    @结束
}

// 多返回值
函数 除法(a, b 整数) (整数, 文本) {
    如果 (b == 0) {
        返回 0, "除数不能为零"
    }
    返回 a / b, ""
}

// 命名返回值（裸返回）
函数 计算(x 整数) (结果 整数, 错误 文本) {
    结果 = x * 2
    返回                     // 裸返回
}

// 可变参数（@嵌入 Go 原生语法）
函数 求和(nums ...整数) 整数 {
    @嵌入
        var sum int
        for _, n range nums {
            sum += n
        }
        return sum
    @结束
}

// 闭包
函数 计数器() {
    @嵌入
        gen := func() func() int {
            i := 0
            return func() int {
                i++
                return i
            }
        }()
        fmt.Println(gen(), gen(), gen())  // 1 2 3
    @结束
}

@嵌入
    type 学生 struct {
        姓名 string
        年龄 int
    }

    // 方法
    func (s *学生) 介绍() string {
        return fmt.Sprintf("我叫%s，今年%d岁", s.姓名, s.年龄)
    }

    // 接口
    type 介绍者 interface {
        介绍() string
    }
@结束

函数 主函数() {
    @嵌入
        s := &学生{姓名: "张三", 年龄: 18}
        fmt.Println(s.介绍())

        // 多态：接口变量接收结构体指针
        var p 介绍者 = s
        fmt.Println(p.介绍())
    @结束
}

函数 读文件(路径 文本) (文本, 文本) {
    @嵌入
        data, err := os.ReadFile(路径)
        if err != nil {
            return "", err.Error()
        }
        return string(data), ""
    @结束
}

函数 安全执行() {
    @嵌入
        defer func() {
            if r := recover(); r != nil {
                fmt.Println("捕获到 panic:", r)
            }
        }()
        panic("主动抛出")
    @结束
}

// Go 原生包导入（必须放在文件顶部 @嵌入 块）
@嵌入
    import (
        "fmt"
        "os"
        "strings"
        "strconv"
    )
@结束

// .elib 支持库自动可用，无需导入
// 例如 libs/golib 提供的 中文命令直接调用：
函数 主函数() {
    变量 s := 取文本中间("abc[123]def", "[", "]")
    打印(s)  // 123
}

// 按钮1 的单击事件
函数 button1_onClick() {
    打印("按钮被点击")
}

// 编辑框1 内容改变事件
函数 edit1_onChanged() {
    打印("内容已改变")
}

// 在窗口设计器中拖入 button，name 设为 btnOK，caption 设为 "确定"
// 双击按钮或在属性面板事件下拉中选择 onClick 自动生成：
函数 btnOK_onClick() {
    打印("用户点击了确定")
}

{
    "version": 1,
    "type": "window",
    "name": "window_main",
    "caption": "我的主窗口",
    "width": 800,
    "height": 600,
    "children": [
        {
            "type": "button",
            "name": "btnOK",
            "caption": "确定",
            "x": 320,
            "y": 520,
            "width": 80,
            "height": 32,
            "events": ["onClick"]
        },
        {
            "type": "edit",
            "name": "editName",
            "placeholder": "请输入姓名",
            "x": 100,
            "y": 100,
            "width": 200,
            "height": 28
        }
    ]
}

{
    "type": "datepicker",
    "label": "日期选择器",
    "icon": "icon.svg",
    "props": { ... },
    "events": [ ... ],
    "preview": "preview.html"
}

@planner #src/main.eg
帮我设计一个文件浏览器功能，左侧目录树，右侧文件预览。

@coder
按 planner 的规划实现 DirTree 组件的事件绑定。

@reviewer
检查我刚写的 window_main.eg 是否有内存泄漏风险。

libs/golib/
├── package.json       # 包元信息（name/version/author）
├── commands.json      # 命令定义
└── source.eg          # 源码

components/<包名>/
├── package.json                    # 包元数据
└── components/
    └── <组件名>/
        ├── config.json             # type/label/icon/props/events/preview
        └── icon.svg                # 图标（可选）

export function activate(api) {
    // 注册自定义左侧面板（G7 插件面板）
    api.registerPanel({
        "icon": "🔧",
        "label": "我的工具",
        "render": renderPanel
    });

    // 注册命令
    api.registerCommand("my.cmd", handler);
}

{
    "name": "窗口程序",
    "description": "带启动窗口的桌面应用",
    "files": ["main.eg", "启动窗口.eg", "启动窗口.ew"]
}

{
    "package": "golib",
    "version": "1.0.0",
    "commands": [
        {
            "zh": "取文本中间",
            "en": "GetMidStr",
            "params": [
                {"name": "源文本", "type": "string"},
                {"name": "左边界", "type": "string"},
                {"name": "右边界", "type": "string"}
            ],
            "returns": "string"
        }
    ]
}

函数 取文本中间(源文本, 左边界, 右边界) {
    @嵌入
        i := strings.Index(源文本, 左边界)
        if i < 0 { return "" }
        i += len(左边界)
        j := strings.Index(源文本[i:], 右边界)
        if j < 0 { return "" }
        return 源文本[i : i+j]
    @结束
}

{
    "type": "datepicker",
    "label": "日期选择器",
    "icon": "icon.svg",
    "defaultSize": {"w": 160, "h": 32},
    "props": {
        "value":     {"type": "string",  "default": ""},
        "format":   {"type": "string",  "default": "yyyy-MM-dd"},
        "minDate": {"type": "string",  "default": ""},
        "maxDate": {"type": "string",  "default": ""}
    },
    "events": ["onChange", "onFocus", "onBlur"],
    "preview": "preview.html"
}

export function activate(api) {
    // 注册左侧面板（G7 插件面板，emoji 图标）
    api.registerPanel({
        "icon": "📊",
        "label": "Git 状态",
        "render": renderGitPanel
    });

    // 注册命令（Ctrl+Shift+P 调用）
    api.registerCommand("git.commit", commitAll);
    api.registerCommand("git.push", pushToRemote);

    // 注册菜单项
    api.registerMenuItem("file/save", {
        "label": "提交并推送",
        "command": "git.commit"
    });

    // 生命周期：插件卸载时清理
    api.onDeactivate(() => {
        clearInterval(timer);
    });
}

function renderGitPanel(container) {
    container.innerHTML = "<div>Loading...</div>";
    refreshStatus(container);
}
function commitAll() { /* ... */ }
function pushToRemote() { /* ... */ }

{
    "name": "计算器",
    "description": "标准计算器应用模板",
    "icon": "icon.svg",
    "files": ["main.eg", "window_main.eg", "window_main.ew"],
    "variables": {
        "PROJECT_NAME": {"prompt": "项目名称", "default": "mycalc"},
        "AUTHOR":       {"prompt": "作者", "default": "匿名"}
    }
}

// 项目：{{PROJECT_NAME}}
// 作者：{{AUTHOR}}
函数 主函数() {
    打印("{{PROJECT_NAME}} 启动")
}

前端 DebugPanel.vue
    ↓ F5 / F10 / F11 / Shift+F11
App.vue → IDEService.DebugContinue / Next / Step / StepOut
    ↓
internal/app/debug.go
    ↓
internal/debugger/client.go（JSON-RPC over TCP）
    ↓
dlv headless 子进程
    ↓
egruntime.exe（带 DWARF 调试信息）

{
    "debug": {
        "enabled": true,
        "port": 8585,
        "initBreakpoint": "main.mainImpl",
        "autoContinue": true,
        "maxArrayLoads": 64,
        "logLevel": "info"
    }
}

// 在循环中只在 i=50 时停下
判断循环 (i < 100) {
    打印(i)            // ← 此行设条件断点：i == 50
    i++
}

main.mainImpl()             src/main.eg:12    ← 当前
module.计算阶乘(5)          src/module/math.eg:8
module.计算阶乘(4)          src/module/math.eg:8
module.计算阶乘(3)          src/module/math.eg:8
main.mainImpl()             src/main.eg:10
runtime.main()              Go runtime

-tags production,netgo,osusergo -trimpath -buildvcs=false \
-ldflags "-w -s"

myego/
├── .eg/                         # IDE 项目元数据（隐藏目录）
│   ├── project.eg.json          # 项目配置
│   ├── layout/                  # 窗口布局描述（IR）
│   │   └── mainwindow.ir.json
│   ├── memory/                  # AI 项目记忆
│   └── cache/                   # 编译缓存
├── src/                         # 源代码目录
│   ├── main.eg                  # 主入口文件
│   ├── window_main.ew           # 主窗口设计文件
│   ├── window_main.eg           # 主窗口代码（事件处理）
│   ├── module/                  # 用户模块
│   └── include/                 # 引用其它共享模块
├── resources/                   # 项目专用资源
├── lib/                         # 第三方库（DLL/静态库）
├── libs/                        # .elib 扩展包
├── out/                         # 编译输出（临时）
└── bin/                         # 最终可执行文件

bin/
├── egruntime-v1.0.0-release.exe          # 主产物
├── egruntime-v1.0.0-release.exe.sha256   # SHA256 校验
├── egruntime-v1.0.1-release.exe          # patch 自增后
└── egruntime-v1.0.1-release.exe.sha256

函数 读配置(路径 文本) 文本 {
    @嵌入
        data, err := os.ReadFile(路径)
        if err != nil {
            return ""
        }
        return string(data)
    @结束
}

@嵌入
    import (
        "fmt"
        "os"
        "sync"
    )

    type Config struct {
        Name string
        Path string
    }

    var (
        cache = map[string]string{}
        mu    sync.Mutex
    )
@结束

函数 主函数() {
    fmt.Println("OK")  // 直接调用 fmt，因为已 import
}

//line src/main.eg:5
func 读配置(路径 string) string {
//line src/main.eg:6
    data, err := os.ReadFile(路径)
//line src/main.eg:7
    if err != nil {
//line src/main.eg:8
        return ""
    }
}

{
    "type": "window",
    "name": "window_main",
    "caption": "计算器",
    "size": {"w": 300, "h": 340},
    "children": [
        {"type": "edit", "name": "editDisplay", "readonly": true, "align": "right", "rect": [20,20,260,40]},
        {"type": "button", "name": "btn7", "caption": "7", "rect": [20,80,60,40]},
        {"type": "button", "name": "btn8", "caption": "8", "rect": [90,80,60,40]}
    ]
}

// 计算器状态（变量声明用类型推断，不写中文类型别名）
变量 当前显示 = ""
变量 上一个操作数 = ""
变量 待执行运算 = ""
变量 刚按等号 = 假

// 数字按钮事件
函数 btn0_onClick()  { 追加数字("0") }
函数 btn1_onClick()  { 追加数字("1") }
函数 btn2_onClick()  { 追加数字("2") }
函数 btn3_onClick()  { 追加数字("3") }
函数 btn4_onClick()  { 追加数字("4") }
函数 btn5_onClick()  { 追加数字("5") }
函数 btn6_onClick()  { 追加数字("6") }
函数 btn7_onClick()  { 追加数字("7") }
函数 btn8_onClick()  { 追加数字("8") }
函数 btn9_onClick()  { 追加数字("9") }

函数 追加数字(d) {
    如果 (刚按等号) {
        当前显示 = ""
        刚按等号 = 假
    }
    当前显示 = 当前显示 + d
    刷新显示()
}

// 运算符按钮事件
函数 btnAdd_onClick() { 选择运算("+") }
函数 btnSub_onClick() { 选择运算("-") }
函数 btnMul_onClick() { 选择运算("*") }
函数 btnDiv_onClick() { 选择运算("/") }

// 且/或是仿易语言别名，以转译器实际支持为准；此处用嵌套如果替代
函数 选择运算(op) {
    如果 (待执行运算 != "") {
        如果 (当前显示 != "") {
            计算结果()
        }
    }
    上一个操作数 = 当前显示
    待执行运算 = op
    当前显示 = ""
}

// 等号按钮
函数 btnEq_onClick() {
    计算结果()
    刚按等号 = 真
}

函数 计算结果() {
    如果 (上一个操作数 == "") {
        返回
    }
    如果 (待执行运算 == "") {
        返回
    }
    如果 (当前显示 == "") {
        返回
    }
    @嵌入
        // @嵌入块内是 Go 原生代码，可用 && || ! 逻辑运算符
        // 中文变量名由转译器处理，可直接引用
        a, err1 := strconv.ParseFloat(上一个操作数, 64)
        b, err2 := strconv.ParseFloat(当前显示, 64)
        if err1 != nil || err2 != nil {
            当前显示 = "错误"
            return
        }
        var r float64
        switch 待执行运算 {
        case "+": r = a + b
        case "-": r = a - b
        case "*": r = a * b
        case "/":
            if b == 0 {
                当前显示 = "除数不能为零"
                return
            }
            r = a / b
        }
        当前显示 = strconv.FormatFloat(r, 'f', -1, 64)
    @结束
    刷新显示()
    上一个操作数 = ""
    待执行运算 = ""
}

// 清除按钮
函数 btnClear_onClick() {
    当前显示 = ""
    上一个操作数 = ""
    待执行运算 = ""
    刚按等号 = 假
    刷新显示()
}

// 刷新编辑框显示
函数 刷新显示() {
    设置组件属性("editDisplay", "text", 当前显示)
}