akm-cli 0.9.0-rc.2 → 0.9.0-rc.4

package/dist/tasks/command-executable.js

@@ -0,0 +1,93 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+const ENV_OPTIONS_WITH_OPERAND = new Set(["--argv0", "--chdir", "--unset"]);
+const ENV_OPTIONS_WITH_OPTIONAL_VALUE = new Set(["--block-signal", "--default-signal", "--ignore-signal"]);
+const ENV_OPTIONS_WITHOUT_OPERAND = new Set(["--debug", "--ignore-environment", "--list-signal-handling"]);
+/** Locate a command whose executable position clearly names AKM, including an explicit path. */
+export function findAkmExecutableIndex(command) {
+    if (command.length === 0)
+        return undefined;
+    const executableIndex = isEnvExecutable(command[0]) ? findEnvCommandIndex(command) : 0;
+    if (executableIndex === undefined || !isAkmExecutable(command[executableIndex]))
+        return undefined;
+    return executableIndex;
+}
+/** Locate only PATH-selected AKM, which is safe to redirect to the current installation. */
+export function findBareAkmExecutableIndex(command) {
+    const executableIndex = findAkmExecutableIndex(command);
+    if (executableIndex === undefined || !isBareAkm(command[executableIndex]))
+        return undefined;
+    return executableIndex;
+}
+function findEnvCommandIndex(command) {
+    let index = 1;
+    while (index < command.length) {
+        const part = command[index];
+        if (part === "--") {
+            index += 1;
+            break;
+        }
+        if (isEnvironmentAssignment(part))
+            break;
+        if (!part.startsWith("-"))
+            break;
+        const operandCount = envOptionOperandCount(part);
+        if (operandCount === undefined || index + operandCount >= command.length)
+            return undefined;
+        index += operandCount + 1;
+    }
+    while (index < command.length && isEnvironmentAssignment(command[index]))
+        index += 1;
+    return index < command.length ? index : undefined;
+}
+function envOptionOperandCount(option) {
+    if (option === "-")
+        return 0;
+    if (ENV_OPTIONS_WITHOUT_OPERAND.has(option) || ENV_OPTIONS_WITH_OPTIONAL_VALUE.has(option))
+        return 0;
+    if ([...ENV_OPTIONS_WITH_OPTIONAL_VALUE].some((prefix) => option.startsWith(`${prefix}=`)))
+        return 0;
+    if (ENV_OPTIONS_WITH_OPERAND.has(option))
+        return 1;
+    if (["--argv0=", "--chdir=", "--unset="].some((prefix) => option.startsWith(prefix)))
+        return 0;
+    if (!option.startsWith("-") || option.startsWith("--"))
+        return undefined;
+    const shortOptions = option.slice(1);
+    for (let index = 0; index < shortOptions.length; index += 1) {
+        const flag = shortOptions[index];
+        if (flag === "i" || flag === "v")
+            continue;
+        if (flag === "S")
+            return undefined;
+        if (flag === "u" || flag === "C" || flag === "P" || flag === "a") {
+            return index === shortOptions.length - 1 ? 1 : 0;
+        }
+        return undefined;
+    }
+    return shortOptions.length > 0 ? 0 : undefined;
+}
+function isEnvironmentAssignment(value) {
+    return /^[A-Za-z_][A-Za-z0-9_]*=/.test(value);
+}
+function isEnvExecutable(value) {
+    if (!value)
+        return false;
+    if (value === "env")
+        return true;
+    if (!isAbsolutePath(value))
+        return false;
+    return /^env(?:\.exe)?$/i.test(value.split(/[\\/]/).at(-1) ?? "");
+}
+function isAbsolutePath(value) {
+    return value.startsWith("/") || value.startsWith("\\\\") || /^[A-Za-z]:[\\/]/.test(value);
+}
+function isBareAkm(value) {
+    return value !== undefined && /^akm(?:\.exe)?$/i.test(value);
+}
+function isAkmExecutable(value) {
+    if (!value)
+        return false;
+    return /^akm(?:\.exe)?$/i.test(value.split(/[\\/]/).at(-1) ?? "");
+}

package/dist/tasks/embedded.js

@@ -58,12 +58,14 @@ export function listEmbeddedTasks() {
         const command = typeof doc.command === "string" ? doc.command : "";
         const schedule = typeof doc.schedule === "string" ? doc.schedule : "";
         const description = typeof doc.description === "string" ? doc.description : "";
+        const enabled = doc.enabled !== false;
         tasks.push({
             id,
             label: `core/${id}`,
             command,
             schedule,
             description,
+            enabled,
             yaml,
         });
     }

package/dist/tasks/parser.js

@@ -37,9 +37,12 @@ import path from "node:path";
 import { parse as parseYaml } from "yaml";
 import { UsageError } from "../core/errors.js";
 import { formatExtraParamsIssue, validateExtraParams } from "../core/extra-params.js";
+import { findBareAkmExecutableIndex } from "./command-executable.js";
 import { TASK_SCHEMA_VERSION } from "./schema.js";
+import { validateTaskId } from "./task-id.js";
 export function parseTaskDocument(input) {
-    const { yaml, filePath, id } = input;
+    const { yaml, filePath } = input;
+    const id = validateTaskId(input.id);
     let data;
     try {
         const parsed = parseYaml(yaml);
@@ -53,6 +56,9 @@ export function parseTaskDocument(input) {
             throw err;
         throw new UsageError(`Task "${id}" has invalid YAML: ${err instanceof Error ? err.message : String(err)}. File: ${filePath}`, "INVALID_FLAG_VALUE");
     }
+    const legacy = data.version === undefined || data.version === 1;
+    if (legacy)
+        data = normalizeV1Task(data, filePath);
     requireVersion(data, id, filePath);
     rejectUnknownKeys(data, id, filePath);
     const schedule = requireString(data.schedule, "schedule", filePath);
@@ -89,7 +95,8 @@ export function parseTaskDocument(input) {
     }
     else if (hasCommand) {
         rejectTargetFields(data, ["timeoutMs"], id, filePath);
-        const cmd = readCommand(data.command, filePath, id);
+        const parsedCommand = readCommand(data.command, filePath, id);
+        const cmd = legacy ? normalizeV1Command(parsedCommand) : parsedCommand;
         target = { kind: "command", cmd };
     }
     else {
@@ -100,7 +107,7 @@ export function parseTaskDocument(input) {
         }
         const engine = optionalString(data.engine, "engine", filePath);
         const model = optionalString(data.model, "model", filePath);
-        const timeoutMs = readTimeout(data.timeoutMs, filePath);
+        const timeoutMs = readTimeout(data.timeoutMs, filePath, legacy);
         const llm = readLlmOverrides(data.llm, filePath);
         target = {
             kind: "prompt",
@@ -111,7 +118,7 @@ export function parseTaskDocument(input) {
             ...(llm ? { llm } : {}),
         };
     }
-    const timeoutMs = hasCommand ? readTimeout(data.timeoutMs, filePath) : undefined;
+    const timeoutMs = hasCommand ? readTimeout(data.timeoutMs, filePath, legacy) : undefined;
     return {
         version: TASK_SCHEMA_VERSION,
         schemaVersion: TASK_SCHEMA_VERSION,
@@ -145,11 +152,138 @@ const TASK_KEYS = new Set([
     "llm",
 ]);
 const SHARED_KEYS = new Set(["version", "name", "description", "when_to_use", "tags", "schedule", "enabled"]);
+/** Lower the complete permissive 0.8 task shape into the strict v2 reader shape. */
+function normalizeV1Task(data, filePath) {
+    const normalized = { version: TASK_SCHEMA_VERSION };
+    for (const key of ["schedule", "workflow", "prompt", "command", "name", "description", "when_to_use"]) {
+        const value = data[key];
+        if (value === undefined || value === null)
+            continue;
+        if (key === "command" && Array.isArray(value)) {
+            normalized[key] = value.filter((part) => typeof part === "string" && part.trim().length > 0);
+        }
+        else if (key === "command") {
+            normalized[key] = value;
+        }
+        else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            normalized[key] = String(value).trim();
+        }
+        else {
+            normalized[key] = value;
+        }
+    }
+    normalized.enabled = data.enabled === undefined ? true : data.enabled === true;
+    if (typeof data.tags === "string") {
+        normalized.tags = data.tags
+            .split(/[\s,]+/)
+            .map((tag) => tag.trim())
+            .filter(Boolean);
+    }
+    else if (Array.isArray(data.tags)) {
+        normalized.tags = data.tags.filter((tag) => typeof tag === "string" && tag.trim().length > 0);
+    }
+    const hasWorkflow = "workflow" in data && data.workflow !== "" && data.workflow != null;
+    const hasPrompt = "prompt" in data && data.prompt !== "" && data.prompt != null;
+    if (hasWorkflow && data.params && typeof data.params === "object" && !Array.isArray(data.params)) {
+        normalized.params = data.params;
+    }
+    else if (hasWorkflow && typeof data.params === "string" && data.params.trim()) {
+        try {
+            const params = JSON.parse(data.params);
+            if (params && typeof params === "object" && !Array.isArray(params))
+                normalized.params = params;
+            else
+                normalized.params = data.params;
+        }
+        catch {
+            normalized.params = data.params;
+        }
+    }
+    if (hasPrompt && data.profile !== undefined && data.profile !== null) {
+        const profile = legacyString(data.profile);
+        if (profile === undefined) {
+            throw new UsageError(`Key "profile" must be a string. File: ${filePath}`, "INVALID_FLAG_VALUE");
+        }
+        if (profile)
+            normalized.engine = profile;
+    }
+    if (!hasWorkflow && "timeoutMs" in data) {
+        const timeout = data.timeoutMs;
+        if (timeout === null || timeout === "null" || timeout === 0 || (typeof timeout === "number" && timeout < 0)) {
+            normalized.timeoutMs = null;
+        }
+        else if (typeof timeout === "number" && timeout > 0) {
+            normalized.timeoutMs = timeout;
+        }
+    }
+    return normalized;
+}
+function legacyString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return value.trim();
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return undefined;
+}
+/** Rewrite only the removed AKM spelling; arbitrary command arguments remain untouched. */
+function normalizeV1Command(cmd) {
+    const akmIndex = findBareAkmExecutableIndex(cmd);
+    if (akmIndex === undefined)
+        return cmd;
+    const improveIndex = findImproveSubcommandIndex(cmd, akmIndex);
+    if (improveIndex === undefined)
+        return cmd;
+    return cmd.map((part, index) => {
+        if (index <= improveIndex)
+            return part;
+        if (part === "--profile")
+            return "--strategy";
+        if (part.startsWith("--profile="))
+            return `--strategy=${part.slice("--profile=".length)}`;
+        return part;
+    });
+}
+const AKM_GLOBAL_BOOLEAN_OPTIONS = new Set([
+    "--quiet",
+    "-q",
+    "--verbose",
+    "--no-quiet",
+    "--no-verbose",
+    "--quiet=false",
+    "--verbose=false",
+]);
+const AKM_GLOBAL_VALUE_OPTIONS = new Set(["--format", "--output", "--detail", "--shape"]);
+function findImproveSubcommandIndex(cmd, akmIndex) {
+    let index = akmIndex + 1;
+    while (index < cmd.length) {
+        const part = cmd[index];
+        if (part === "improve")
+            return index;
+        if (AKM_GLOBAL_BOOLEAN_OPTIONS.has(part)) {
+            index += 1;
+            continue;
+        }
+        if (AKM_GLOBAL_VALUE_OPTIONS.has(part)) {
+            if (index + 1 >= cmd.length)
+                return undefined;
+            index += 2;
+            continue;
+        }
+        if ([...AKM_GLOBAL_VALUE_OPTIONS].some((option) => part.startsWith(`${option}=`) && part.length > option.length + 1)) {
+            index += 1;
+            continue;
+        }
+        return undefined;
+    }
+    return undefined;
+}
 function requireVersion(data, id, filePath) {
     if (data.version === TASK_SCHEMA_VERSION)
         return;
     const actual = data.version === undefined ? "missing" : JSON.stringify(data.version);
-    throw new UsageError(`TASK_SCHEMA_VERSION_UNSUPPORTED: Task "${id}" uses task schema version ${actual}; version: 2 is required. File: ${filePath}`, "TASK_SCHEMA_VERSION_UNSUPPORTED", "Rewrite the task using version: 2 and replace profile with engine.");
+    throw new UsageError(`TASK_SCHEMA_VERSION_UNSUPPORTED: Task "${id}" uses task schema version ${actual}; version: 2 is required. File: ${filePath}`, "TASK_SCHEMA_VERSION_UNSUPPORTED", "Use task schema version: 2.");
 }
 function rejectUnknownKeys(data, id, filePath) {
     const unknown = Object.keys(data).filter((key) => !TASK_KEYS.has(key));
@@ -247,11 +381,13 @@ function readParams(value, filePath) {
     }
     throw new UsageError(`Key "params" must be a mapping. File: ${filePath}`, "INVALID_FLAG_VALUE");
 }
-function readTimeout(value, filePath) {
+function readTimeout(value, filePath, legacy = false) {
     if (value === undefined)
         return undefined;
     if (value === null)
         return null;
+    if (legacy && typeof value === "number" && Number.isFinite(value) && value > 0)
+        return value;
     if (typeof value === "number" && Number.isInteger(value) && value > 0)
         return value;
     throw new UsageError(`Key "timeoutMs" must be a positive integer or null. File: ${filePath}`, "INVALID_FLAG_VALUE");

package/dist/tasks/resolve-akm-bin.js

@@ -10,10 +10,11 @@
  * Resolution order:
  *
  *   1. `$AKM_BIN` (explicit override; takes precedence everywhere).
- *   2. `process.execPath` + the resolved CLI script — works when running
+ *   2. `process.execPath` alone for a Bun standalone executable.
+ *   3. `process.execPath` + the resolved CLI script — works when running
  *      from a development checkout (`bun /repo/src/cli.ts`) and from a
  *      compiled install (`bun /opt/akm/dist/cli.js`).
- *   3. `which akm` / `where akm` — last resort when the binary is on PATH
+ *   4. `which akm` / `where akm` — last resort when the binary is on PATH
  *      but neither override applies.
  *
  * Returns the argv array the scheduler should execute (e.g.
@@ -25,15 +26,25 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { ConfigError } from "../core/errors.js";
+import { mainPath as runtimeMainPath } from "../runtime.js";
 export function resolveAkmInvocation(options = {}) {
     const env = options.env ?? process.env;
     const override = env.AKM_BIN?.trim();
     if (override) {
         return { argv: [override], via: "AKM_BIN" };
     }
+    const runtime = options.runtime ?? (process.versions.bun ? "bun" : "node");
+    const execPath = options.execPath ?? process.execPath;
+    const mainPath = options.mainPath ?? runtimeMainPath;
+    const isStandaloneMain = mainPath?.startsWith("/$bunfs/") || (mainPath !== undefined && /^[A-Za-z]:[\\/]~BUN[\\/]/i.test(mainPath));
+    if (runtime === "bun" && isStandaloneMain && execPath) {
+        return { argv: [execPath], via: "execPath" };
+    }
     const cliPath = resolveCliEntry(options.cliEntryUrl ?? import.meta.url);
-    if (cliPath && process.execPath) {
-        return { argv: [process.execPath, cliPath], via: "execPath" };
+    if (cliPath && execPath) {
+        const entry = runtime === "node" ? resolveNodeCliEntry(cliPath) : cliPath;
+        if (entry)
+            return { argv: [execPath, entry], via: "execPath" };
     }
     const whichBin = findOnPath("akm", env);
     if (whichBin) {
@@ -41,6 +52,10 @@ export function resolveAkmInvocation(options = {}) {
     }
     throw new ConfigError("Cannot resolve absolute path to the akm binary for scheduler registration.", "INVALID_CONFIG_FILE", "Set AKM_BIN to the absolute path of the akm binary, or ensure `akm` is on PATH.");
 }
+function resolveNodeCliEntry(cliPath) {
+    const wrapper = path.join(path.dirname(cliPath), "cli-node.mjs");
+    return fs.existsSync(wrapper) ? wrapper : undefined;
+}
 /**
  * From the URL of a module inside `src/tasks/` figure out the CLI entry.
  *