akm-cli 0.9.31 → 0.10.26101002-alpha

package/dist/commands/tasks/validate.js

@@ -1,176 +0,0 @@
-// 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/.
-/**
- * `akm task validate <path>` (#907) — parse ONE task file by filesystem
- * path, not a concept ref/id, and report the same diagnostic `akm task
- * sync` would produce for it. The file need not live in any configured
- * bundle: unlike every other `akm task` subcommand, this one never resolves
- * a bundle/adapter/concept id at all — it reads exactly the path it was
- * given and classifies it.
- *
- * Reuses the exact version router `parseTaskSource`
- * (`src/tasks/source/parse-task-source.ts`) every other task-source reader
- * uses (`akm task sync`'s `compileTaskSources` included) — this module never
- * forks a second parser. `readBoundedTaskSourceYaml` /
- * `peekTaskSourceVersion` / `own` are the SAME front-end helpers the router
- * calls first; they are used here only to recover the file's DECLARED schema
- * version for the report and to tell `blocked` from `invalid`.
- *
- * Beyond parsing, this module also runs the SAME two per-source gates
- * `akm task sync`'s `compileTaskSources` runs before it ever installs a
- * schedule — `assertTaskScheduleInputsSatisfyContract` and
- * `assertTaskScheduleCronValid` (both extracted from `scheduler-sync.ts` for
- * exactly this reuse) — so a file `sync` would reject can never
- * be reported `valid` here. Cron dialect is checked against
- * `backendNameForPlatform()`, the same platform default `sync` falls back
- * to whenever it has no injected/native-inspected backend to hand (see
- * `akmTasksAdd`, `src/commands/tasks/tasks.ts`); a bare file was never
- * installed anywhere; there is no native scheduler state to inspect for it.
- *
- * Deliberately DOES NOT call `prepareTaskV3Execution` (the function
- * `compileTaskSources` calls between those two gates) or resolve an
- * execution engine: that path resolves a composed command/persona ref
- * against the local index and lowers the task's cascade-composed
- * engine/model — both of which assume a real, indexed bundle and a
- * configured engine. A bare file passed to `validate` has neither, so
- * running that step would make an otherwise-valid command-kind task report
- * `invalid` on any machine with no engine configured. `resolved`
- * is therefore the compiled task shape `sync` itself would build a
- * scheduler binding from — id, the compiled v4 `version`, `target`
- * (`uses`/`run`), the declared `inputs` contract, and `schedule` bindings —
- * never an execution-lowered plan.
- *
- * Outcome classification (mirrors `parse-task-source.ts`'s own routing
- * table in its header, extended for the two gates above):
- *   - `valid`       — parses as task source v4 and passes both sync gates.
- *   - `blocked`     — declared `version: 2` or `3`, or a `version: 4`
- *                      document still carrying the retired
- *                      `schedule[].enabled`: what `akm migrate apply`
- *                      rewrites. The runtime reads only v4 (#987), so the
- *                      reason names that command.
- *   - `invalid`     — the document declares SOME version (`4`, or anything
- *                      other than 2/3/4) but fails to parse/validate, OR it
- *                      parsed but fails one of the two sync gates above, OR
- *                      the YAML itself does not parse at all (a genuine
- *                      syntax error, not merely a non-task shape) — reported
- *                      with the parser's own reason.
- *   - `not-a-task`  — the document parses as YAML but never declares a
- *                      `version:` field at all (or isn't a YAML mapping) —
- *                      the strongest signal available that the file was
- *                      never intended as a task source in the first place.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { UsageError } from "../../core/errors.js";
-import { backendNameForPlatform } from "../../tasks/backends/index.js";
-import { assertTaskScheduleCronValid, assertTaskScheduleInputsSatisfyContract } from "../../tasks/scheduler-sync.js";
-import { own, readBoundedTaskSourceYaml } from "../../tasks/source/bounded-document.js";
-import { parseTaskSource, peekTaskSourceVersion, v4ScheduleHasRetiredEnabledKey, } from "../../tasks/source/parse-task-source.js";
-/** True when `root` is a YAML mapping that itself declares a `version:` key, regardless of that key's type/value. */
-function declaresVersionKey(root) {
-    return root !== null && typeof root === "object" && !Array.isArray(root) && own(root, "version");
-}
-function buildResolved(id, v4) {
-    return {
-        id,
-        version: v4.version,
-        ...(v4.name !== undefined ? { name: v4.name } : {}),
-        ...(v4.description !== undefined ? { description: v4.description } : {}),
-        target: v4.target,
-        inputs: v4.inputs ?? {},
-        schedule: v4.schedule,
-    };
-}
-export async function akmTaskValidate(filePath) {
-    const resolvedPath = path.resolve(filePath);
-    let stat;
-    try {
-        stat = fs.statSync(resolvedPath);
-    }
-    catch {
-        throw new UsageError(`Task file not found: ${JSON.stringify(filePath)}.`, "INVALID_FLAG_VALUE");
-    }
-    if (!stat.isFile()) {
-        throw new UsageError(`${JSON.stringify(filePath)} is not a regular file.`, "INVALID_FLAG_VALUE");
-    }
-    let yaml;
-    try {
-        yaml = fs.readFileSync(resolvedPath, "utf8");
-    }
-    catch (cause) {
-        throw new UsageError(`Task file ${JSON.stringify(filePath)} could not be read: ${cause instanceof Error ? cause.message : String(cause)}`, "INVALID_FLAG_VALUE");
-    }
-    // Peek the declared version BEFORE the real parse, using the identical
-    // bounded YAML front end `parseTaskSource` calls internally — never a
-    // second/looser YAML reader. A front-end failure here (unparseable YAML,
-    // not a mapping, exceeds a resource bound) means the document itself does
-    // not parse at all — tracked as `peekFailed` so that case reports
-    // `invalid`, never `not-a-task` (`not-a-task` is reserved for
-    // YAML that DOES parse but never declared a task shape). The real parse
-    // below throws the identical error either way, so nothing is lost by
-    // swallowing it here.
-    let root;
-    let peekFailed = false;
-    try {
-        root = readBoundedTaskSourceYaml({ yaml, filePath: resolvedPath }, { sourceLabel: "task source" }).root;
-    }
-    catch {
-        peekFailed = true;
-    }
-    const declaredVersion = peekFailed ? undefined : peekTaskSourceVersion(root);
-    const hasVersionKey = !peekFailed && declaresVersionKey(root);
-    const workspaceRoot = path.dirname(resolvedPath);
-    const backend = backendNameForPlatform();
-    let parsed;
-    try {
-        parsed = parseTaskSource({ yaml, filePath: resolvedPath, workspaceRoot });
-    }
-    catch (cause) {
-        if (!(cause instanceof UsageError))
-            throw cause;
-        const reason = cause.message;
-        // What `akm migrate apply` rewrites is the only refusal for these
-        // shapes (`parse-task-source.ts`), so no message-text sniffing is needed.
-        if (declaredVersion === 2 ||
-            declaredVersion === 3 ||
-            (declaredVersion === 4 && v4ScheduleHasRetiredEnabledKey(root))) {
-            return { ok: false, path: resolvedPath, sourceVersion: declaredVersion, outcome: "blocked", reason };
-        }
-        if (peekFailed) {
-            return { ok: false, path: resolvedPath, outcome: "invalid", reason };
-        }
-        if (!hasVersionKey) {
-            return { ok: false, path: resolvedPath, outcome: "not-a-task", reason };
-        }
-        return {
-            ok: false,
-            path: resolvedPath,
-            ...(declaredVersion !== undefined ? { sourceVersion: declaredVersion } : {}),
-            outcome: "invalid",
-            reason,
-        };
-    }
-    // Success is unreachable from any path that leaves `declaredVersion`
-    // undefined — the router requires a numeric version 4 to reach here.
-    const sourceVersion = declaredVersion ?? 4;
-    // The document itself parsed — now the two gates `compileTaskSources`
-    // runs before accepting it. A violation here is `invalid`.
-    try {
-        assertTaskScheduleInputsSatisfyContract(parsed.v4, resolvedPath);
-        assertTaskScheduleCronValid(parsed.v4, backend);
-    }
-    catch (cause) {
-        if (!(cause instanceof UsageError))
-            throw cause;
-        return { ok: false, path: resolvedPath, sourceVersion, outcome: "invalid", reason: cause.message };
-    }
-    const id = path.parse(resolvedPath).name;
-    return {
-        ok: true,
-        path: resolvedPath,
-        sourceVersion,
-        outcome: "valid",
-        resolved: buildResolved(id, parsed.v4),
-    };
-}

package/dist/core/config/legacy-source-shape-shim.js

@@ -1,117 +0,0 @@
-import path from "node:path";
-import { isBundleSlug } from "../asset/asset-ref.js";
-import { warnOnce } from "../warn.js";
-function isPlainRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-const DEFAULT_WRITABLE_BY_TYPE = {
-    filesystem: true,
-    git: false,
-    website: false,
-    npm: false,
-};
-function bundleFromLegacySource(entry, index) {
-    if (!isPlainRecord(entry))
-        return undefined;
-    const type = typeof entry.type === "string" ? entry.type : undefined;
-    const bundle = {};
-    switch (type) {
-        case "filesystem":
-            if (typeof entry.path !== "string" || !entry.path)
-                return undefined;
-            bundle.path = entry.path;
-            break;
-        case "git":
-            if (typeof entry.url !== "string" || !entry.url)
-                return undefined;
-            bundle.git = entry.url;
-            break;
-        case "website":
-            if (typeof entry.url !== "string" || !entry.url)
-                return undefined;
-            bundle.website = { url: entry.url };
-            break;
-        case "npm": {
-            const spec = typeof entry.url === "string" && entry.url ? entry.url : entry.path;
-            if (typeof spec !== "string" || !spec)
-                return undefined;
-            bundle.npm = spec;
-            break;
-        }
-        default:
-            return undefined;
-    }
-    const writable = typeof entry.writable === "boolean" ? entry.writable : DEFAULT_WRITABLE_BY_TYPE[type ?? ""];
-    if (writable !== undefined)
-        bundle.writable = writable;
-    if (typeof entry.enabled === "boolean")
-        bundle.enabled = entry.enabled;
-    const name = typeof entry.name === "string" ? entry.name : undefined;
-    const key = name && isBundleSlug(name) ? name : `source-${index + 1}`;
-    return [key, bundle];
-}
-function filesystemLocator(bundle) {
-    if (!isPlainRecord(bundle) || typeof bundle.path !== "string" || bundle.path.length === 0)
-        return undefined;
-    return path.resolve(bundle.path);
-}
-/**
- * Pure legacy `stashDir`/`sources[]`/`installed` -> `bundles`/`defaultBundle`
- * conversion. Triggers on key *presence* (not on the value being usable), so
- * an unusable value — `stashDir: ""`, `sources: []` — is still removed along
- * with the rest of the legacy shape; only a usable `stashDir` or `sources[]`
- * entry is actually folded into `bundles`. Never warns — see
- * {@link migrateLegacySourceShape} for the warn-once wrapper callers use.
- */
-export function convertLegacySourceShape(raw) {
-    const hasStashDir = "stashDir" in raw;
-    const hasSources = "sources" in raw;
-    const hasInstalled = "installed" in raw && raw.installed !== undefined;
-    if (!hasStashDir && !hasSources && !hasInstalled)
-        return { config: raw, converted: [] };
-    const { stashDir: _stashDir, sources: _sources, installed: _installed, ...rest } = raw;
-    const bundles = isPlainRecord(rest.bundles) ? { ...rest.bundles } : {};
-    let defaultBundle = typeof rest.defaultBundle === "string" ? rest.defaultBundle : undefined;
-    const usableStashDir = typeof raw.stashDir === "string" && raw.stashDir.trim().length > 0;
-    if (usableStashDir) {
-        bundles.stash = { path: raw.stashDir, writable: true };
-        defaultBundle ??= "stash";
-    }
-    if (Array.isArray(raw.sources)) {
-        raw.sources.forEach((entry, index) => {
-            const converted = bundleFromLegacySource(entry, index);
-            if (!converted)
-                return;
-            const [key, bundle] = converted;
-            const locator = filesystemLocator(bundle);
-            if (locator && Object.values(bundles).some((candidate) => filesystemLocator(candidate) === locator))
-                return;
-            bundles[key] = bundle;
-            defaultBundle ??= key;
-        });
-    }
-    const converted = [hasStashDir && "stashDir", hasSources && "sources", hasInstalled && "installed"].filter((key) => typeof key === "string");
-    // Only add a `bundles` key when there is something to say: either a
-    // legacy entry actually converted into one, or the config already had a
-    // `bundles` map (preserved as-is). An unusable `stashDir: ""` / `sources: []`
-    // with no pre-existing `bundles` should just disappear, not leave behind
-    // an empty `bundles: {}`.
-    const hasBundles = Object.keys(bundles).length > 0 || isPlainRecord(rest.bundles);
-    return {
-        config: { ...rest, ...(hasBundles ? { bundles } : {}), ...(defaultBundle !== undefined ? { defaultBundle } : {}) },
-        converted,
-    };
-}
-/**
- * Warn-once wrapper around {@link convertLegacySourceShape} for the
- * in-memory read path: converts the legacy shape and, when it removed
- * anything, warns once that `akm migrate apply` will persist the rewrite.
- */
-export function migrateLegacySourceShape(raw, sourcePath) {
-    const { config, converted } = convertLegacySourceShape(raw);
-    if (converted.length === 0)
-        return config;
-    const where = sourcePath ? ` at ${sourcePath}` : "";
-    warnOnce(`legacy-source-shape${sourcePath ? `:${sourcePath}` : ""}`, `Config${where} uses the retired ${converted.join("/")} shape — auto-migrated in memory to \`bundles\`/\`defaultBundle\`. Run \`akm migrate apply\` to rewrite the config file and silence this warning.`);
-    return config;
-}

package/dist/integrations/harnesses/ids.js

@@ -1,28 +0,0 @@
-// 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/.
-export const HARNESS_ID_TABLE = [
-    { id: "opencode", agentDispatch: true, enforcesModelWorkTools: true, nativeAgentSelector: true },
-    { id: "claude", agentDispatch: true, enforcesModelWorkTools: true, nativeAgentSelector: true },
-    { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true, nativeAgentSelector: true },
-    { id: "codex", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "pi", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "aider", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-];
-/**
- * Canonical, ordered list of valid harness / platform ids — the
- * dependency-free counterpart of `./index.ts`'s `VALID_HARNESS_IDS` (which
- * remains the barrel's own derivation for its own consumers). Both are
- * asserted equal at `HARNESS_REGISTRY` construction time.
- */
-export const VALID_HARNESS_IDS = Object.freeze(HARNESS_ID_TABLE.map((h) => h.id));
-/** Harness ids whose `capabilities.agentDispatch` is `true`. */
-export const HARNESS_AGENT_DISPATCH_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.agentDispatch).map((h) => h.id));
-/** Harness ids that confine the model-work tool policy, so unattended model work may run on them. */
-export const HARNESS_MODEL_WORK_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.enforcesModelWorkTools).map((h) => h.id));
-/** Harness ids that can run a named native agent, so an engine may name a default `agent`. */
-export const HARNESS_NATIVE_AGENT_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.nativeAgentSelector).map((h) => h.id));