@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/config-TDYOC7XO.js

@@ -0,0 +1,519 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import "./chunk-C3B7C43W.js";
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/config.ts
+import { loadConfig } from "@cleocode/core/config";
+import { CleoError } from "@cleocode/core/errors";
+
+// packages/cleo/src/cli/commands/config/drift-check.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { checkDrift } from "@cleocode/core/config/registry";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+var configDriftCheckCommand = defineCommand({
+  meta: {
+    name: "drift-check",
+    description: "Check a scoped config file for drift (default scope: project; metadata covers project-info/project-context)"
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Scope to check: global | project | metadata (default project)",
+      default: "project"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const scope = parseDriftScope(args["scope"]);
+    if (scope === null) {
+      cliError(
+        `config drift-check failed: invalid --scope (must be global|project|metadata)`,
+        ExitCode.GENERAL_ERROR,
+        { name: "E_CONFIG_DRIFT_CHECK_FAILED" }
+      );
+      process.exit(ExitCode.GENERAL_ERROR);
+      return;
+    }
+    let driftResult;
+    try {
+      const projectRoot = getProjectRoot();
+      driftResult = await checkDrift(scope, projectRoot);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`config drift-check failed: ${message}`, ExitCode.GENERAL_ERROR, {
+        name: "E_CONFIG_DRIFT_CHECK_FAILED"
+      });
+      process.exit(ExitCode.GENERAL_ERROR);
+      return;
+    }
+    const result = {
+      scope,
+      drift: driftResult.drift,
+      ...driftResult.reason !== void 0 ? { reason: driftResult.reason } : {}
+    };
+    cliOutput(result, {
+      command: "config-drift-check",
+      operation: "config.drift-check"
+    });
+    if (driftResult.drift) {
+      process.exit(ExitCode.VALIDATION_ERROR);
+    }
+  }
+});
+function parseDriftScope(raw) {
+  const value = raw ?? "project";
+  if (value === "global" || value === "project" || value === "metadata") {
+    return value;
+  }
+  return null;
+}
+
+// packages/cleo/src/cli/commands/config/get.ts
+import { ExitCode as ExitCode2 } from "@cleocode/contracts/exit-codes.js";
+import { getConfigValue } from "@cleocode/core/config/registry";
+import { getProjectRoot as getProjectRoot2 } from "@cleocode/core/project-scope";
+var configGetCommand = defineCommand({
+  meta: {
+    name: "get",
+    description: "Read a single config value by dot-separated key (default scope: merged)"
+  },
+  args: {
+    key: {
+      type: "positional",
+      required: true,
+      description: "Dot-separated key path (e.g. release.branchModel)"
+    },
+    scope: {
+      type: "string",
+      description: "Cascade scope to read: global | project | merged (default merged)",
+      default: "merged"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const key = String(args["key"] ?? "").trim();
+    if (key.length === 0) {
+      cliError(`config get failed: <key> is required`, ExitCode2.INVALID_INPUT, {
+        name: "E_CONFIG_GET_FAILED"
+      });
+      process.exit(ExitCode2.INVALID_INPUT);
+      return;
+    }
+    const scope = parseResolveScope(args["scope"]);
+    if (scope === null) {
+      cliError(
+        `config get failed: invalid --scope (must be global|project|merged)`,
+        ExitCode2.GENERAL_ERROR,
+        { name: "E_CONFIG_GET_FAILED" }
+      );
+      process.exit(ExitCode2.GENERAL_ERROR);
+      return;
+    }
+    let value;
+    try {
+      const projectRoot = getProjectRoot2();
+      value = await getConfigValue(key, { scope, projectRoot });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`config get failed: ${message}`, ExitCode2.GENERAL_ERROR, {
+        name: "E_CONFIG_GET_FAILED"
+      });
+      process.exit(ExitCode2.GENERAL_ERROR);
+      return;
+    }
+    if (value === void 0) {
+      cliError(`config get failed: key "${key}" not found`, ExitCode2.NOT_FOUND, {
+        name: "E_NOT_FOUND",
+        details: { key, scope }
+      });
+      process.exit(ExitCode2.NOT_FOUND);
+      return;
+    }
+    const result = { scope, key, value };
+    cliOutput(result, {
+      command: "config-get",
+      operation: "config.get"
+    });
+  }
+});
+function parseResolveScope(raw) {
+  const value = raw ?? "merged";
+  if (value === "global" || value === "project" || value === "merged") {
+    return value;
+  }
+  return null;
+}
+
+// packages/cleo/src/cli/commands/config/set.ts
+import { ExitCode as ExitCode3 } from "@cleocode/contracts/exit-codes.js";
+import { parseConfigValue, setConfigValue } from "@cleocode/core/config";
+import { validateConfig } from "@cleocode/core/config/registry";
+import { getProjectRoot as getProjectRoot3 } from "@cleocode/core/project-scope";
+var configSetCommand = defineCommand({
+  meta: {
+    name: "set",
+    description: "Write a value into project or global .cleo/config.json"
+  },
+  args: {
+    key: {
+      type: "positional",
+      required: true,
+      description: "Dot-separated key path"
+    },
+    value: {
+      type: "positional",
+      required: true,
+      description: "Raw value (string). Use --type to coerce explicitly."
+    },
+    scope: {
+      type: "string",
+      description: "Where to write: project | global (default project)",
+      default: "project"
+    },
+    type: {
+      type: "string",
+      description: "Explicit value type: string | number | boolean | json"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const key = String(args["key"] ?? "").trim();
+    if (key.length === 0) {
+      cliError(`config set failed: <key> is required`, ExitCode3.INVALID_INPUT, {
+        name: "E_CONFIG_SET_FAILED"
+      });
+      process.exit(ExitCode3.INVALID_INPUT);
+      return;
+    }
+    const rawValue = String(args["value"] ?? "");
+    const scope = parseWriteScope(args["scope"]);
+    if (scope === null) {
+      cliError(
+        `config set failed: invalid --scope (must be global|project)`,
+        ExitCode3.GENERAL_ERROR,
+        { name: "E_CONFIG_SET_FAILED" }
+      );
+      process.exit(ExitCode3.GENERAL_ERROR);
+      return;
+    }
+    const typeFlag = args["type"];
+    let coerced;
+    try {
+      coerced = coerceValue(rawValue, typeFlag);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`config set failed: ${message}`, ExitCode3.INVALID_INPUT, {
+        name: "E_CONFIG_SET_FAILED"
+      });
+      process.exit(ExitCode3.INVALID_INPUT);
+      return;
+    }
+    let written;
+    let validate;
+    try {
+      const projectRoot = getProjectRoot3();
+      written = await setConfigValue(key, coerced, projectRoot, {
+        global: scope === "global"
+      });
+      validate = await validateConfig(scope, projectRoot);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`config set failed: ${message}`, ExitCode3.GENERAL_ERROR, {
+        name: "E_CONFIG_SET_FAILED"
+      });
+      process.exit(ExitCode3.GENERAL_ERROR);
+      return;
+    }
+    const result = {
+      scope: written.scope,
+      key: written.key,
+      value: written.value,
+      validate
+    };
+    cliOutput(result, {
+      command: "config-set",
+      operation: "config.set"
+    });
+    if (!validate.ok) {
+      process.exit(ExitCode3.VALIDATION_ERROR);
+    }
+  }
+});
+function parseWriteScope(raw) {
+  const value = raw ?? "project";
+  if (value === "global" || value === "project") {
+    return value;
+  }
+  return null;
+}
+function coerceValue(raw, typeFlag) {
+  if (typeFlag === void 0) return parseConfigValue(raw);
+  if (typeFlag === "string") return raw;
+  if (typeFlag === "number") return coerceNumber(raw);
+  if (typeFlag === "boolean") return coerceBoolean(raw);
+  if (typeFlag === "json") return coerceJson(raw);
+  throw new Error(`--type must be one of: string | number | boolean | json (got "${typeFlag}")`);
+}
+function coerceNumber(raw) {
+  const n = Number(raw);
+  if (Number.isNaN(n)) {
+    throw new Error(`--type number cannot coerce "${raw}"`);
+  }
+  return n;
+}
+function coerceBoolean(raw) {
+  const lower = raw.toLowerCase();
+  if (lower === "true") return true;
+  if (lower === "false") return false;
+  throw new Error(`--type boolean accepts only "true"/"false" (got "${raw}")`);
+}
+function coerceJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`--type json failed to parse: ${msg}`);
+  }
+}
+
+// packages/cleo/src/cli/commands/config/show.ts
+import { ExitCode as ExitCode4 } from "@cleocode/contracts/exit-codes.js";
+import {
+  resolveCleoConfig
+} from "@cleocode/core/config/registry";
+import { getProjectRoot as getProjectRoot4 } from "@cleocode/core/paths.js";
+var configShowCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Print the resolved CleoConfig envelope (default scope: merged)"
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Cascade scope to read: global | project | merged (default merged)",
+      default: "merged"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const scope = parseResolveScope2(args["scope"]);
+    if (scope === null) {
+      cliError(
+        `config show failed: invalid --scope (must be global|project|merged)`,
+        ExitCode4.GENERAL_ERROR,
+        { name: "E_CONFIG_SHOW_FAILED" }
+      );
+      process.exit(ExitCode4.GENERAL_ERROR);
+      return;
+    }
+    try {
+      const projectRoot = getProjectRoot4();
+      const config = await resolveCleoConfig({ scope, projectRoot });
+      const result = { scope, config };
+      cliOutput(result, {
+        command: "config-show",
+        operation: "config.show"
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`config show failed: ${message}`, ExitCode4.GENERAL_ERROR, {
+        name: "E_CONFIG_SHOW_FAILED"
+      });
+      process.exit(ExitCode4.GENERAL_ERROR);
+    }
+  }
+});
+function parseResolveScope2(raw) {
+  const value = raw ?? "merged";
+  if (value === "global" || value === "project" || value === "merged") {
+    return value;
+  }
+  return null;
+}
+
+// packages/cleo/src/cli/commands/config/validate.ts
+import { ExitCode as ExitCode5 } from "@cleocode/contracts/exit-codes.js";
+import { validateConfig as validateConfig2 } from "@cleocode/core/config/registry";
+import { getProjectRoot as getProjectRoot5 } from "@cleocode/core/paths.js";
+var configValidateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate a scoped config file against its schema (default scope: project)"
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Scope to validate: global | project (default project)",
+      default: "project"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const scope = parseValidateScope(args["scope"]);
+    if (scope === null) {
+      cliError(
+        `config validate failed: invalid --scope (must be global|project)`,
+        ExitCode5.GENERAL_ERROR,
+        { name: "E_CONFIG_VALIDATE_FAILED" }
+      );
+      process.exit(ExitCode5.GENERAL_ERROR);
+      return;
+    }
+    let validate;
+    try {
+      const projectRoot = getProjectRoot5();
+      validate = await validateConfig2(scope, projectRoot);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`config validate failed: ${message}`, ExitCode5.GENERAL_ERROR, {
+        name: "E_CONFIG_VALIDATE_FAILED"
+      });
+      process.exit(ExitCode5.GENERAL_ERROR);
+      return;
+    }
+    const result = {
+      scope,
+      ok: validate.ok,
+      issues: validate.issues
+    };
+    cliOutput(result, {
+      command: "config-validate",
+      operation: "config.validate"
+    });
+    if (!validate.ok) {
+      process.exit(ExitCode5.VALIDATION_ERROR);
+    }
+  }
+});
+function parseValidateScope(raw) {
+  const value = raw ?? "project";
+  if (value === "global" || value === "project") {
+    return value;
+  }
+  return null;
+}
+
+// packages/cleo/src/cli/commands/config.ts
+var PRESET_DESCRIPTIONS = {
+  strict: "Block on missing AC, require session notes, enforce lifecycle pipeline.",
+  standard: "Warn on missing AC, optional session notes, advisory lifecycle pipeline.",
+  minimal: "No AC checking, no session requirement, lifecycle pipeline off."
+};
+var setPresetCommand = defineCommand({
+  meta: {
+    name: "set-preset",
+    description: [
+      "Apply a strictness preset to the project config (strict | standard | minimal)",
+      `  strict   \u2014 ${PRESET_DESCRIPTIONS["strict"]}`,
+      `  standard \u2014 ${PRESET_DESCRIPTIONS["standard"]}`,
+      `  minimal  \u2014 ${PRESET_DESCRIPTIONS["minimal"]}`
+    ].join("\n\n")
+  },
+  args: {
+    preset: {
+      type: "positional",
+      description: "Preset name (strict | standard | minimal)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "config.set-preset",
+      { preset: args.preset },
+      { command: "config" }
+    );
+  }
+});
+var presetsCommand = defineCommand({
+  meta: { name: "presets", description: "List all available strictness presets" },
+  async run() {
+    await dispatchFromCli("query", "admin", "config.presets", {}, { command: "config" });
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "Show all resolved configuration" },
+  async run() {
+    try {
+      const resolved = await loadConfig();
+      cliOutput({ config: resolved }, { command: "config" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(`config list failed: ${err.message}`, err.code, { name: "E_CONFIG_LOAD" });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var configCommand = defineCommand({
+  meta: {
+    name: "config",
+    description: "CleoConfig SSoT registry surface (show, get, set, validate, drift-check) + legacy presets/list"
+  },
+  subCommands: {
+    show: configShowCommand,
+    get: configGetCommand,
+    set: configSetCommand,
+    validate: configValidateCommand,
+    "drift-check": configDriftCheckCommand,
+    "set-preset": setPresetCommand,
+    presets: presetsCommand,
+    list: listCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  configCommand
+};
+//# sourceMappingURL=config-TDYOC7XO.js.map

package/dist/cli/consensus-4XCOFPPT.js

@@ -0,0 +1,122 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/consensus.ts
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate consensus protocol compliance for task"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to validate",
+      required: true
+    },
+    strict: {
+      type: "boolean",
+      description: "Exit with error code on violations"
+    },
+    "voting-matrix": {
+      type: "string",
+      description: "Path to voting matrix JSON file"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "protocol",
+      {
+        protocolType: "consensus",
+        mode: "task",
+        taskId: args.taskId,
+        strict: args.strict,
+        votingMatrixFile: args["voting-matrix"]
+      },
+      { command: "consensus" }
+    );
+  }
+});
+var checkCommand = defineCommand({
+  meta: {
+    name: "check",
+    description: "Validate manifest entry directly"
+  },
+  args: {
+    manifestFile: {
+      type: "positional",
+      description: "Path to manifest file",
+      required: true
+    },
+    strict: {
+      type: "boolean",
+      description: "Exit with error code on violations"
+    },
+    "voting-matrix": {
+      type: "string",
+      description: "Path to voting matrix JSON file"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "protocol",
+      {
+        protocolType: "consensus",
+        mode: "manifest",
+        manifestFile: args.manifestFile,
+        strict: args.strict,
+        votingMatrixFile: args["voting-matrix"]
+      },
+      { command: "consensus" }
+    );
+  }
+});
+var consensusCommand = defineCommand({
+  meta: {
+    name: "consensus",
+    description: "Validate consensus protocol compliance (alias for `cleo check protocol consensus`)"
+  },
+  subCommands: {
+    validate: validateCommand,
+    check: checkCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  consensusCommand
+};
+//# sourceMappingURL=consensus-4XCOFPPT.js.map