kenaz 0.3.1 → 0.3.3

package/core/k-cli/dist/dispatch/run.js

@@ -0,0 +1,241 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const path = __importStar(require("path"));
+const project_1 = require("../core/project");
+const process_1 = require("../core/process");
+const spawn_1 = require("../core/spawn");
+const output_1 = require("../core/output");
+async function run(taskId, opts = {}) {
+    const isAuto = opts.auto === true;
+    const hasTaskId = taskId && taskId.startsWith("TASK_");
+    if (!isAuto && !hasTaskId) {
+        console.error("Usage:");
+        console.error("  k-cli dispatch run TASK_XXX          # dispatch 指定任務");
+        console.error("  k-cli dispatch run --auto            # 自動掃描待辦任務並 dispatch");
+        process.exit(1);
+    }
+    const project = (0, project_1.resolveProject)(opts.projectPath);
+    const corePath = project.core_path;
+    // Assemble Ansuz prompt
+    const sessionJs = path.join(corePath, ".specialist", "tools", "session.js");
+    let ansuzPrompt;
+    try {
+        ansuzPrompt = await (0, process_1.nodeProcess)([sessionJs, "prompt", "Ansuz", "--mode=assembled", "--no-muninn"], corePath, 15000);
+    }
+    catch (e) {
+        console.error("Error: Failed to assemble Ansuz prompt:", e.message);
+        process.exit(1);
+    }
+    const headlessV2Path = path.join(corePath, ".formation", "tools", "headless-v2.js");
+    const headlessV1Path = path.join(corePath, ".formation", "tools", "headless.js");
+    const taskApiPath = path.join(corePath, ".collaboration", "core", "task-api.js");
+    const roleMapPath = path.join(corePath, ".formation", "role-map.yaml");
+    const projectPathFlag = project.mode === "sub-project" ? ` --project-path "${project.path}"` : "";
+    // headless-v2.js 雙軸架構：
+    //   --base = do|plan|think（行為模式，來自 unit/*.yaml）
+    //   --role = developer|frontend|...（角色專業，來自 role-map.yaml 對照表）
+    // 已內建：Auto-claim、依賴預檢、Post-complete、Auto-select
+    //
+    // Ansuz 的職責：讀取任務 role → 決定 --base 和 --role
+    const formationReference = `
+## Formation Headless V2 參考
+
+### headless-v2.js 雙軸架構
+- **--base**：行為模式（do=執行, plan=規劃, think=分析）
+- **--role**：角色專業（從 role-map.yaml 查找，注入角色 identity 和 strengths）
+
+### headless-v2.js 已自動處理
+- Auto-claim（backlog → active）
+- 依賴預檢（dependencies 未滿足會擋住）
+- Post-complete（archive + git）
+你不需要手動 claim 或 complete，只需正確組合參數。
+
+### Role 對照表
+先讀取 ${roleMapPath} 了解所有可用 role。
+每個 role 有 skill_path、identity、strengths、best_for、not_for。
+
+常見 role：
+| role | 說明 | 適合 |
+|------|------|------|
+| developer | 泛用開發者（全棧） | 跨前後端、系統整合 |
+| frontend | 前端開發 | React/TypeScript UI |
+| backend | 後端工程 | API、DB、Python |
+| designer | UI/UX 設計 | 設計規範產出 |
+| qa | QA 工程師 | 測試、Bug 驗證 |
+| sre | SRE | 基礎設施、部署 |
+
+### Base 選擇
+| base | 用途 | 適合情境 |
+|------|------|---------|
+| do（預設） | 直接執行，交付成果 | 功能開發、Bug 修復 |
+| plan | 拆解問題，交付行動方案 | 需求分析、任務拆解 |
+| think | 深入分析，交付結論 | 根因調查、架構評估 |
+
+### 進階陣型（非 unit）
+如任務複雜度超出 unit 能力，改用 headless.js（V1）：
+| 陣型 | 條件 | headless.js 參數 |
+|------|------|-----------------|
+| solo | 需多角度分析 | --formation=solo --skill=strategy --task=TASK_XXX |
+| squad | 多子任務可並行 | --formation=squad --skill=blitz --task=TASK_XXX |
+| legion | 有順序依賴 | --formation=legion --skill=forge --task=TASK_XXX |
+`;
+    let dispatchInstruction;
+    if (hasTaskId) {
+        // === 指定任務模式 ===
+        dispatchInstruction = `
+[k-cli dispatch run — 指定任務模式]
+
+你正在被 k-cli 以非互動方式呼叫。不要詢問用戶問題、不要等待確認。直接執行，遇到錯誤直接輸出錯誤訊息並結束。
+
+## 你的任務
+
+Dispatch 指定任務：${taskId}
+
+${formationReference}
+
+## 執行步驟（必須依序完成）
+
+### Step 1: 讀取任務詳情
+\`\`\`bash
+node "${taskApiPath}"${projectPathFlag} get ${taskId}
+\`\`\`
+確認任務存在。記下 role 欄位。
+
+### Step 2: 判斷 --base 和 --role
+1. **讀取 ${roleMapPath}** 了解所有可用 role 及其 strengths
+2. 任務的 role 欄位 → 作為 --role 值
+3. 根據任務性質判斷 --base（do=執行, plan=規劃, think=分析），預設 do
+4. **輸出決策說明**：說明為什麼選了這個 base 和 role
+
+### Step 3: Dispatch
+使用 headless-v2.js（雙軸架構）：
+\`\`\`bash
+# unit（最常用）— headless-v2.js
+node "${headlessV2Path}" --base={base} --role={role} --task=${taskId}${projectPathFlag}
+
+# 進階陣型 — 仍用 headless.js（V1）
+node "${headlessV1Path}" --formation={formation} --skill={skill} --task=${taskId}${projectPathFlag}
+\`\`\`
+headless-v2.js 會自動處理 claim、依賴檢查、post-complete。
+
+### Step 4: 輸出結果
+輸出：
+- 任務 ID、role、--base、--role、dispatch 狀態
+- **決策理由**：為什麼選這個 base（任務性質）、為什麼選這個 role（role-map 的 strengths 匹配）
+
+## 專案資訊
+- 專案路徑：${project.path}
+- Core 路徑：${corePath}
+- 模式：${project.mode}
+`;
+    }
+    else {
+        // === Auto 模式（掃描全部待辦） ===
+        dispatchInstruction = `
+[k-cli dispatch run --auto — 自動掃描模式]
+
+你正在被 k-cli 以非互動方式呼叫。不要詢問用戶問題、不要等待確認。直接執行，遇到錯誤直接輸出錯誤訊息並結束。
+
+## 你的任務
+
+掃描所有待辦任務，判斷陣型與 skill，依序 dispatch。
+
+${formationReference}
+
+## 執行步驟
+
+### Step 1: 查看待辦任務
+\`\`\`bash
+node "${taskApiPath}"${projectPathFlag} list --status backlog
+\`\`\`
+如果沒有待辦任務，輸出「無待辦任務」並結束。
+
+### Step 2: 分析每個任務
+對每個待辦任務：
+1. 讀取詳情（task get）→ 記下 role
+2. **讀取 ${roleMapPath}** 確認 role 存在且了解其 strengths
+3. 判斷 --base（do/plan/think）和 --role
+4. 輸出每個任務的決策理由（base 選擇原因、role 匹配原因）
+
+### Step 3: 依序 Dispatch
+按優先級（P0 > P1 > P2 > P3）排序，逐個執行 headless-v2.js：
+\`\`\`bash
+node "${headlessV2Path}" --base={base} --role={role} --task=TASK_XXX${projectPathFlag}
+\`\`\`
+- headless-v2.js 自動處理 claim、依賴檢查、post-complete
+- 無依賴的任務可並行 dispatch（上限 5）
+- 有依賴的等前置完成再 dispatch
+
+### Step 4: 輸出結果
+輸出所有 dispatch 的任務摘要表格：任務 ID、標題、--base、--role、決策理由、狀態。
+
+## 專案資訊
+- 專案路徑：${project.path}
+- Core 路徑：${corePath}
+- 模式：${project.mode}
+`;
+    }
+    const fullPrompt = `${ansuzPrompt}\n\n${dispatchInstruction}`;
+    const mode = hasTaskId ? taskId : "--auto";
+    if (opts.dryRun) {
+        const dryResult = {
+            dryRun: true,
+            action: "dispatch run",
+            mode,
+            promptLength: fullPrompt.length,
+            projectPath: project.path,
+        };
+        if (opts.json) {
+            (0, output_1.output)(dryResult, { json: true });
+        }
+        else {
+            console.log(`\n[dry-run] dispatch run ${mode}`);
+            console.log(`  Project: ${project.path}`);
+            console.log(`  Prompt length: ${fullPrompt.length.toLocaleString()} chars`);
+            console.log("  Would spawn Ansuz (not executed)");
+        }
+        return;
+    }
+    console.log(`Dispatching via Ansuz (${mode})...`);
+    console.log(`  Project: ${project.path}`);
+    const child = (0, spawn_1.spawnClaude)({
+        prompt: fullPrompt,
+        cwd: corePath,
+        projectPath: project.mode === "sub-project" ? project.path : null,
+    });
+    return (0, spawn_1.streamClaudeOutput)(child);
+}

package/core/k-cli/dist/dispatch/status.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const project_1 = require("../core/project");
+const process_1 = require("../core/process");
+async function run(taskId, opts = {}) {
+    if (!taskId) {
+        console.error("Error: task ID is required");
+        process.exit(1);
+    }
+    const project = (0, project_1.resolveProject)(opts.projectPath);
+    const corePath = project.core_path;
+    const logReaderJs = path.join(corePath, ".formation", "tools", "log-reader.js");
+    const tail = opts.tail || 50;
+    // Determine log directory: sub-project uses .kenaz/logs/, core uses .formation/logs/
+    const logsDir = project.mode === "sub-project"
+        ? path.join(project.path, ".kenaz", "logs")
+        : path.join(corePath, ".formation", "logs");
+    // Search for the latest log containing the taskId
+    let logFile = null;
+    if (fs.existsSync(logsDir)) {
+        const formations = ["unit", "solo", "squad", "legion", "misc", "legacy"];
+        let latestTime = 0;
+        for (const f of formations) {
+            const dir = path.join(logsDir, f);
+            if (!fs.existsSync(dir))
+                continue;
+            const files = fs.readdirSync(dir).filter((name) => name.endsWith(".log"));
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                const stat = fs.statSync(filePath);
+                // Check if log content mentions taskId (by filename pattern or content)
+                if (file.toLowerCase().includes(taskId.toLowerCase()) ||
+                    stat.mtimeMs > latestTime) {
+                    // Read first few lines to check if it mentions the task
+                    const head = fs.readFileSync(filePath, "utf-8").slice(0, 2000);
+                    if (head.includes(taskId)) {
+                        if (stat.mtimeMs > latestTime) {
+                            latestTime = stat.mtimeMs;
+                            logFile = filePath;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (!logFile) {
+        // Fallback: try log-reader.js --task (searches core logs)
+        try {
+            const result = await (0, process_1.nodeProcess)([logReaderJs, "--task", taskId, "--tail", String(tail)], corePath);
+            console.log(result);
+            return;
+        }
+        catch {
+            console.error(`No log found for ${taskId}`);
+            process.exit(1);
+        }
+    }
+    // Use log-reader.js --log <path> for the found log
+    try {
+        const result = await (0, process_1.nodeProcess)([logReaderJs, "--log", logFile, "--tail", String(tail)], corePath);
+        console.log(result);
+    }
+    catch (e) {
+        console.error(`Error: ${e.message}`);
+        process.exit(1);
+    }
+}

package/core/k-cli/dist/index.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const project_1 = require("./core/project");
+const args = process.argv.slice(2);
+const command = args[0];
+const subcommand = args[1];
+// Positional arg after subcommand (e.g. task get TASK_123)
+const positional = args[2] && !args[2].startsWith("--") ? args[2] : undefined;
+// Collect all non-flag args after subcommand as free-text prompt
+const positionalAll = args.slice(2).filter((a) => !a.startsWith("--")).join(" ") || undefined;
+function parseFlags(argv) {
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--json")
+            flags.json = true;
+        else if (arg === "--dry-run")
+            flags.dryRun = true;
+        else if (arg === "--help" || arg === "-h")
+            flags.help = true;
+        else if (arg.startsWith("--project-path="))
+            flags.projectPath = arg.split("=")[1];
+        else if (arg === "--project-path" && argv[i + 1])
+            flags.projectPath = argv[++i];
+        else if (arg.startsWith("--agent="))
+            flags.agent = arg.split("=")[1];
+        else if (arg === "--agent" && argv[i + 1])
+            flags.agent = argv[++i];
+        else if (arg.startsWith("--prompt="))
+            flags.prompt = arg.split("=")[1];
+        else if (arg === "--prompt" && argv[i + 1])
+            flags.prompt = argv[++i];
+        else if (arg.startsWith("--max-length="))
+            flags.maxLength = parseInt(arg.split("=")[1], 10);
+        else if (arg === "--max-length" && argv[i + 1])
+            flags.maxLength = parseInt(argv[++i], 10);
+        else if (arg.startsWith("--status="))
+            flags.status = arg.split("=")[1];
+        else if (arg === "--status" && argv[i + 1])
+            flags.status = argv[++i];
+        else if (arg.startsWith("--title="))
+            flags.title = arg.split("=")[1];
+        else if (arg === "--title" && argv[i + 1])
+            flags.title = argv[++i];
+        else if (arg.startsWith("--priority="))
+            flags.priority = arg.split("=")[1];
+        else if (arg === "--priority" && argv[i + 1])
+            flags.priority = argv[++i];
+        else if (arg.startsWith("--formation="))
+            flags.formation = arg.split("=")[1];
+        else if (arg === "--formation" && argv[i + 1])
+            flags.formation = argv[++i];
+        else if (arg.startsWith("--skill="))
+            flags.skill = arg.split("=")[1];
+        else if (arg === "--skill" && argv[i + 1])
+            flags.skill = argv[++i];
+        else if (arg.startsWith("--tail="))
+            flags.tail = parseInt(arg.split("=")[1], 10);
+        else if (arg === "--tail" && argv[i + 1])
+            flags.tail = parseInt(argv[++i], 10);
+        else if (arg === "--no-git")
+            flags.initGit = false;
+        else if (arg.startsWith("--core-path="))
+            flags.corePath = arg.split("=")[1];
+        else if (arg === "--core-path" && argv[i + 1])
+            flags.corePath = argv[++i];
+        else if (arg === "--force")
+            flags.force = true;
+        else if (arg === "--auto")
+            flags.auto = true;
+    }
+    return flags;
+}
+const flags = parseFlags(args);
+if (!command || flags.help) {
+    console.log(`
+k-cli — KenazAI CLI
+
+Usage: k-cli <command> [subcommand] [options]
+
+Commands:
+  specialist list                   List all Specialists (name + prompt)
+  specialist run --agent <name>     Run a Specialist
+  task list                         List tasks
+  task get <id>                     Get task details
+  task create --title <title>       Create task (via Ansuz)
+  task submit --title <t> ...       Create task directly (no Ansuz; for scripts/processes)
+  task delete <id>                  Delete task
+  dispatch run <taskId>             Dispatch specific task (via Ansuz)
+  dispatch run --auto               Auto-scan & dispatch all pending tasks
+  dispatch status <taskId>          Check dispatch status
+  dashboard version                 Show current Dashboard version
+  dashboard update                  Check for update and install
+  dashboard update --force          Auto-install without prompt
+  project status                    Project overview
+  project initialize                Initialize sub-project (.kenaz/)
+  project install <target>          Install template (e.g. k-cli)
+  ygg join <key> [--project|--global]  Join Yggdrasil without the Dashboard
+  ygg status | ygg leave            Room/relay/peers/mail; remove project key
+  alaya register                    Register this device with Alaya (device-code login, no Dashboard)
+  alaya status                      Alaya registered / not registered + outbox depth
+  ping                              Health check
+
+Global Options:
+  --json                  Output JSON format
+  --dry-run               Validate without executing
+  --project-path <path>   Specify sub-project path
+  --help, -h              Show help
+`);
+    process.exit(0);
+}
+(async () => {
+    try {
+        switch (command) {
+            case "specialist": {
+                if (subcommand === "list") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./specialist/list")));
+                    await run(flags);
+                }
+                else if (subcommand === "run") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./specialist/run")));
+                    await run(positionalAll || "", flags);
+                }
+                else {
+                    console.error(`Unknown subcommand: specialist ${subcommand}`);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "task": {
+                if (subcommand === "list") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./task/list")));
+                    await run(flags);
+                }
+                else if (subcommand === "get") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./task/get")));
+                    await run(positional || "", flags);
+                }
+                else if (subcommand === "create") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./task/create")));
+                    await run(positionalAll || "", flags);
+                }
+                else if (subcommand === "submit") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./task/submit")));
+                    await run(args.slice(2), flags);
+                }
+                else if (subcommand === "delete") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./task/delete")));
+                    await run(positional || "", flags);
+                }
+                else {
+                    console.error(`Unknown subcommand: task ${subcommand}`);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "dispatch": {
+                if (subcommand === "run") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./dispatch/run")));
+                    await run(positional || "", flags);
+                }
+                else if (subcommand === "status") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./dispatch/status")));
+                    await run(positional || "", flags);
+                }
+                else {
+                    console.error(`Unknown subcommand: dispatch ${subcommand}`);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "dashboard": {
+                if (subcommand === "version") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./dashboard/version")));
+                    await run(flags);
+                }
+                else if (subcommand === "update") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./dashboard/update")));
+                    await run(flags);
+                }
+                else {
+                    console.error(`Unknown subcommand: dashboard ${subcommand}`);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "project": {
+                if (subcommand === "status") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./project/status")));
+                    await run(flags);
+                }
+                else if (subcommand === "initialize" || subcommand === "init") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./project/initialize")));
+                    await run(flags);
+                }
+                else if (subcommand === "install") {
+                    const { run } = await Promise.resolve().then(() => __importStar(require("./project/install")));
+                    await run(positional || "", flags);
+                }
+                else {
+                    console.error(`Unknown subcommand: project ${subcommand}`);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "ygg": {
+                const { run } = await Promise.resolve().then(() => __importStar(require("./ygg/run")));
+                run(args.slice(1));
+                break;
+            }
+            case "alaya": {
+                const mod = await Promise.resolve().then(() => __importStar(require("./alaya/run")));
+                if (subcommand === "register")
+                    await mod.register(flags);
+                else if (subcommand === "status")
+                    await mod.status(flags);
+                else {
+                    console.error(`Unknown subcommand: alaya ${subcommand}`);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "ping": {
+                const project = (0, project_1.resolveProject)(flags.projectPath);
+                const result = {
+                    status: "ok",
+                    version: "0.1.0",
+                    project: project.name,
+                    mode: project.mode,
+                    corePath: project.core_path,
+                };
+                if (flags.json) {
+                    console.log(JSON.stringify(result, null, 2));
+                }
+                else {
+                    console.log(`k-cli v0.1.0 — ${project.name} (${project.mode})`);
+                }
+                break;
+            }
+            default:
+                console.error(`Unknown command: ${command}`);
+                process.exit(1);
+        }
+    }
+    catch (e) {
+        console.error(`Error: ${e.message}`);
+        process.exit(1);
+    }
+})();