easy-coding-harness 0.1.4

package/dist/cli.js

@@ -0,0 +1,979 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import chalk6 from "chalk";
+import { Command } from "commander";
+
+// src/commands/add-agent.ts
+import path8 from "path";
+import { outro } from "@clack/prompts";
+import chalk2 from "chalk";
+
+// src/configurators/claude.ts
+import path4 from "path";
+
+// src/types/platform.ts
+var pythonCmd = process.platform === "win32" ? "python" : "python3";
+var PLATFORM_META = {
+  "claude-code": {
+    label: "Claude Code",
+    skillsDir: ".claude/skills",
+    hooksDir: ".claude/hooks",
+    hookConfigFile: ".claude/settings.json",
+    agentsDir: ".claude/agents",
+    agentFileExt: ".md",
+    mainConstraint: "CLAUDE.md",
+    skillTrigger: "/",
+    hookEvents: ["SessionStart", "PreToolUse", "UserPromptSubmit", "Stop"],
+    stateInjectEvent: ["SessionStart", "UserPromptSubmit"],
+    hasSubagentContext: true,
+    templateContext: {
+      sub_agent_dispatch: "Agent tool",
+      platform_spawn_instruction: 'Use the Agent tool with run_in_background when useful; use isolation: "worktree" for parallel file edits.',
+      skill_trigger: "/",
+      workflow_state_path: ".easy-coding/state.json",
+      main_constraint_file: "CLAUDE.md",
+      python_cmd: pythonCmd,
+      platform_config_dir: ".claude"
+    }
+  },
+  codex: {
+    label: "Codex",
+    skillsDir: ".agents/skills",
+    hooksDir: ".codex/hooks",
+    hookConfigFile: ".codex/hooks.json",
+    agentsDir: ".codex/agents",
+    agentFileExt: ".toml",
+    mainConstraint: "AGENTS.md",
+    skillTrigger: "$",
+    hookEvents: ["UserPromptSubmit"],
+    stateInjectEvent: ["UserPromptSubmit"],
+    hasSubagentContext: false,
+    templateContext: {
+      sub_agent_dispatch: "Codex sub-agent dispatch",
+      platform_spawn_instruction: "Use Codex sub-agent delegation where available; pass the full task card in the prompt.",
+      skill_trigger: "$",
+      workflow_state_path: ".easy-coding/state.json",
+      main_constraint_file: "AGENTS.md",
+      python_cmd: pythonCmd,
+      platform_config_dir: ".codex"
+    }
+  },
+  qoder: {
+    label: "Qoder",
+    skillsDir: ".qoder/skills",
+    hooksDir: ".qoder/hooks",
+    hookConfigFile: ".qoder/settings.json",
+    agentsDir: ".qoder/agents",
+    agentFileExt: ".md",
+    mainConstraint: "AGENTS.md",
+    skillTrigger: "/",
+    hookEvents: ["UserPromptSubmit", "PreToolUse", "Stop"],
+    stateInjectEvent: ["UserPromptSubmit"],
+    hasSubagentContext: true,
+    cnVariant: ".qodercn",
+    templateContext: {
+      sub_agent_dispatch: "Agent tool",
+      platform_spawn_instruction: "Use the Agent tool with worktree isolation for parallel file edits.",
+      skill_trigger: "/",
+      workflow_state_path: ".easy-coding/state.json",
+      main_constraint_file: "AGENTS.md",
+      python_cmd: pythonCmd,
+      platform_config_dir: ".qoder"
+    }
+  }
+};
+var AGENT_PLATFORMS = Object.keys(PLATFORM_META);
+function isAgentPlatform(value) {
+  return Object.hasOwn(PLATFORM_META, value);
+}
+
+// src/configurators/shared.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import path3 from "path";
+
+// src/constants/paths.ts
+var EASY_CODING_DIR = ".easy-coding";
+var CONFIG_FILE = "config.yaml";
+var STATE_FILE = "state.json";
+var TASKS_DIR = "tasks";
+var PROJECT_INIT_TASK_ID = "project-init";
+var MEMORY_DIR = "memory";
+var SPEC_DIR = "spec";
+var MAIN_SPEC_DIR = "main";
+var DEV_SPEC_DIR = "dev";
+var STATE_GITIGNORE_ENTRY = ".easy-coding/state.json";
+var GENERATED_REGION_START = "<!-- \u2550\u2550\u2550 easy-coding-harness generated (DO NOT EDIT BETWEEN MARKERS) \u2550\u2550\u2550 -->";
+var GENERATED_REGION_END = "<!-- \u2550\u2550\u2550 end easy-coding-harness generated \u2550\u2550\u2550 -->";
+
+// src/utils/file-writer.ts
+import { constants } from "fs";
+import { access, cp, writeFile as fsWriteFile, mkdir, readFile, stat } from "fs/promises";
+import path from "path";
+async function pathExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function writeTextFile(filePath, content) {
+  await ensureDir(path.dirname(filePath));
+  await fsWriteFile(filePath, content.endsWith("\n") ? content : `${content}
+`, "utf8");
+}
+async function readTextFile(filePath) {
+  return readFile(filePath, "utf8");
+}
+async function readTextIfExists(filePath) {
+  if (!await pathExists(filePath)) {
+    return null;
+  }
+  return readTextFile(filePath);
+}
+async function isDirectory(filePath) {
+  try {
+    return (await stat(filePath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/marked-region.ts
+var MarkedRegionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MarkedRegionError";
+  }
+};
+function extractMarkedRegion(content) {
+  const start = content.indexOf(GENERATED_REGION_START);
+  const end = content.indexOf(GENERATED_REGION_END);
+  if (start === -1 && end === -1) {
+    return null;
+  }
+  if (start === -1 || end === -1 || end < start) {
+    throw new MarkedRegionError("Generated region markers are incomplete or out of order.");
+  }
+  return content.slice(start, end + GENERATED_REGION_END.length);
+}
+function replaceMarkedRegion(existing, generatedRegion) {
+  const currentRegion = extractMarkedRegion(existing);
+  if (!currentRegion) {
+    return `${generatedRegion.trim()}
+
+${existing.trimStart()}`.trimEnd();
+  }
+  return existing.replace(currentRegion, generatedRegion.trim());
+}
+
+// src/utils/template-paths.ts
+import { existsSync } from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function getTemplateRoot() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path2.resolve(here, "../templates"),
+    path2.resolve(here, "../../templates"),
+    path2.resolve(process.cwd(), "src/templates"),
+    path2.resolve(process.cwd(), "templates")
+  ];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  if (!found) {
+    throw new Error(`Unable to locate templates directory. Tried: ${candidates.join(", ")}`);
+  }
+  return found;
+}
+function getTemplatePath(...segments) {
+  return path2.join(getTemplateRoot(), ...segments);
+}
+
+// src/configurators/shared.ts
+var UnresolvedPlaceholderError = class extends Error {
+  constructor(contentName, placeholders) {
+    super(`Unresolved placeholders in ${contentName}: ${placeholders.join(", ")}`);
+    this.name = "UnresolvedPlaceholderError";
+  }
+};
+function resolvePlaceholders(content, ctx, contentName = "template") {
+  const withPython = content.replace(/\{\{PYTHON_CMD\}\}/g, ctx.python_cmd);
+  const resolved = withPython.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = ctx[key];
+    return value === void 0 ? match : String(value);
+  });
+  const unresolved = [...resolved.matchAll(/\{\{[^}]+\}\}/g)].map((match) => match[0]);
+  if (unresolved.length > 0) {
+    throw new UnresolvedPlaceholderError(contentName, unresolved);
+  }
+  return resolved;
+}
+async function resolveSkills(ctx) {
+  const skillsRoot = getTemplatePath("common", "skills");
+  const entries = await readdir(skillsRoot);
+  const skills = [];
+  for (const entry of entries.sort()) {
+    const skillDir = path3.join(skillsRoot, entry);
+    if (!await isDirectory(skillDir)) {
+      continue;
+    }
+    const content = await readTextFile(path3.join(skillDir, "SKILL.md"));
+    skills.push({
+      name: entry,
+      content: resolvePlaceholders(content, ctx, `common/skills/${entry}/SKILL.md`)
+    });
+  }
+  return skills;
+}
+async function resolveBundledSkills(ctx) {
+  const bundledRoot = getTemplatePath("common", "bundled-skills");
+  if (!await pathExists(bundledRoot)) {
+    return [];
+  }
+  const entries = await readdir(bundledRoot);
+  const bundled = [];
+  for (const entry of entries.sort()) {
+    const sourceDir = path3.join(bundledRoot, entry);
+    if (await isDirectory(sourceDir)) {
+      bundled.push({ name: entry, sourceDir, context: ctx });
+    }
+  }
+  return bundled;
+}
+async function writeSkills(dir, skills, bundled) {
+  await ensureDir(dir);
+  for (const skill of skills) {
+    await writeTextFile(path3.join(dir, skill.name, "SKILL.md"), skill.content);
+  }
+  for (const skill of bundled) {
+    await copyTemplateDirectory(skill.sourceDir, path3.join(dir, skill.name), skill.context);
+  }
+}
+async function writeSharedHooks(dir, platform, opts = {}) {
+  const hooksRoot = getTemplatePath("shared-hooks");
+  const ctx = PLATFORM_META[platform].templateContext;
+  const entries = await readdir(hooksRoot);
+  await ensureDir(dir);
+  for (const entry of entries.sort()) {
+    if (opts.skipSubagentContext && entry === "inject-subagent-context.py") {
+      continue;
+    }
+    const sourcePath = path3.join(hooksRoot, entry);
+    if ((await stat2(sourcePath)).isDirectory()) {
+      continue;
+    }
+    const content = resolvePlaceholders(
+      await readTextFile(sourcePath),
+      ctx,
+      `shared-hooks/${entry}`
+    );
+    const destination = path3.join(dir, entry);
+    await writeTextFile(destination, content);
+    await import("fs/promises").then(({ chmod }) => chmod(destination, 493));
+  }
+}
+async function copyPlatformTemplates(platformTemplateDir, destination, skipDirs, ctx) {
+  const source = getTemplatePath(platformTemplateDir);
+  await copyTemplateDirectory(source, destination, ctx, new Set(skipDirs));
+}
+async function writeMainConstraint(cwd, platform) {
+  const meta = PLATFORM_META[platform];
+  const ctx = meta.templateContext;
+  const templateName = `${meta.mainConstraint}.tpl`;
+  const template = await readTextFile(getTemplatePath("main-constraint", templateName));
+  const generated = resolvePlaceholders(template, ctx, `main-constraint/${templateName}`);
+  if (!generated.includes(GENERATED_REGION_START) || !generated.includes(GENERATED_REGION_END)) {
+    throw new Error(`Main constraint template ${templateName} does not contain generated markers.`);
+  }
+  const destination = path3.join(cwd, meta.mainConstraint);
+  const current = await readTextIfExists(destination);
+  const next = current ? replaceMarkedRegion(current, generated) : generated;
+  await writeTextFile(destination, next);
+}
+async function copyTemplateDirectory(source, destination, ctx, skipDirs = /* @__PURE__ */ new Set()) {
+  await ensureDir(destination);
+  for (const entry of (await readdir(source)).sort()) {
+    if (skipDirs.has(entry) || shouldSkipTemplateEntry(entry)) {
+      continue;
+    }
+    const sourcePath = path3.join(source, entry);
+    const destinationPath = path3.join(destination, stripTemplateExtension(entry));
+    const sourceStat = await stat2(sourcePath);
+    if (sourceStat.isDirectory()) {
+      await copyTemplateDirectory(sourcePath, destinationPath, ctx, skipDirs);
+      continue;
+    }
+    const content = resolvePlaceholders(await readTextFile(sourcePath), ctx, sourcePath);
+    await writeTextFile(destinationPath, content);
+  }
+}
+function shouldSkipTemplateEntry(entry) {
+  return entry === ".DS_Store" || entry === "__pycache__" || entry.endsWith(".ts") || entry.endsWith(".js") || entry.endsWith(".map");
+}
+function stripTemplateExtension(fileName) {
+  return fileName.endsWith(".tpl") ? fileName.slice(0, -4) : fileName;
+}
+
+// src/configurators/claude.ts
+async function configureClaude(cwd) {
+  const platform = "claude-code";
+  const meta = PLATFORM_META[platform];
+  const ctx = meta.templateContext;
+  const dest = path4.join(cwd, ".claude");
+  await copyPlatformTemplates("claude", dest, ["hooks"], ctx);
+  await writeSharedHooks(path4.join(dest, "hooks"), platform);
+  await writeSkills(
+    path4.join(cwd, meta.skillsDir),
+    await resolveSkills(ctx),
+    await resolveBundledSkills(ctx)
+  );
+  await writeMainConstraint(cwd, platform);
+}
+
+// src/configurators/codex.ts
+import path5 from "path";
+async function configureCodex(cwd) {
+  const platform = "codex";
+  const meta = PLATFORM_META[platform];
+  const ctx = meta.templateContext;
+  await writeSkills(
+    path5.join(cwd, meta.skillsDir),
+    await resolveSkills(ctx),
+    await resolveBundledSkills(ctx)
+  );
+  await writeSharedHooks(path5.join(cwd, meta.hooksDir), platform, { skipSubagentContext: true });
+  await copyPlatformTemplates("codex", path5.join(cwd, ".codex"), ["hooks"], ctx);
+  await writeMainConstraint(cwd, platform);
+}
+
+// src/configurators/qoder.ts
+import { existsSync as existsSync2 } from "fs";
+import path6 from "path";
+async function configureQoder(cwd) {
+  const platform = "qoder";
+  const baseDir = detectQoderCnVariant(cwd) ? ".qodercn" : ".qoder";
+  const ctx = {
+    ...PLATFORM_META[platform].templateContext,
+    platform_config_dir: baseDir
+  };
+  const dest = path6.join(cwd, baseDir);
+  await copyPlatformTemplates("qoder", dest, ["hooks"], ctx);
+  await writeSharedHooks(path6.join(dest, "hooks"), platform);
+  await writeSkills(
+    path6.join(dest, "skills"),
+    await resolveSkills(ctx),
+    await resolveBundledSkills(ctx)
+  );
+  await writeMainConstraint(cwd, platform);
+}
+function detectQoderCnVariant(cwd) {
+  if (process.env.EC_QODER_VARIANT === "cn" || process.env.QODER_VARIANT === "cn") {
+    return true;
+  }
+  return existsSync2(path6.join(cwd, ".qodercn"));
+}
+
+// src/configurators/index.ts
+var CONFIGURATORS = {
+  "claude-code": configureClaude,
+  codex: configureCodex,
+  qoder: configureQoder
+};
+
+// src/ui/banner.ts
+import chalk from "chalk";
+import figlet from "figlet";
+
+// src/constants/version.ts
+import { readFileSync } from "fs";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var packageMetadata = readPackageMetadata();
+var PACKAGE_NAME = packageMetadata.name;
+var VERSION = packageMetadata.version;
+function readPackageMetadata() {
+  const here = path7.dirname(fileURLToPath2(import.meta.url));
+  const candidates = [
+    path7.resolve(here, "../../package.json"),
+    path7.resolve(here, "../package.json"),
+    path7.resolve(process.cwd(), "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+      if (parsed.name && parsed.version) {
+        return { name: parsed.name, version: parsed.version };
+      }
+    } catch {
+    }
+  }
+  throw new Error(`Unable to locate package metadata. Tried: ${candidates.join(", ")}`);
+}
+
+// src/ui/banner.ts
+var WIDE_TERMINAL_WIDTH = 88;
+var MEDIUM_TERMINAL_WIDTH = 72;
+function renderBanner() {
+  const terminalWidth = process.stdout.columns ?? 120;
+  const art = figlet.textSync("Easy Coding", selectBannerPreset(terminalWidth));
+  console.log(colorizeBanner(art));
+  console.log(chalk.bold.white(`  Easy Coding Harness  ${chalk.cyan(`v${VERSION}`)}
+`));
+}
+function selectBannerPreset(width) {
+  if (width >= WIDE_TERMINAL_WIDTH) {
+    return { font: "ANSI Shadow", horizontalLayout: "full" };
+  }
+  if (width >= MEDIUM_TERMINAL_WIDTH) {
+    return { font: "Small Shadow", horizontalLayout: "full" };
+  }
+  return { font: "Small Slant" };
+}
+function colorizeBanner(art) {
+  const colors = [chalk.cyanBright, chalk.cyan, chalk.blueBright, chalk.blue];
+  return art.split("\n").map((line, index) => colors[index % colors.length](line)).join("\n");
+}
+
+// src/utils/config-yaml.ts
+import { readFile as readFile2 } from "fs/promises";
+import YAML, { isScalar, isSeq, parseDocument } from "yaml";
+function createDefaultConfig(params) {
+  return {
+    version: 1,
+    harness_version: params.harnessVersion,
+    agents: params.agents,
+    project: {
+      name: params.projectName,
+      mode: "auto"
+    },
+    memory: {
+      short_term_max: 10,
+      short_term_keep: 5,
+      schema_version: 2
+    },
+    test: {
+      framework: "auto",
+      command: ""
+    },
+    tasks: {
+      auto_archive_days: 30
+    },
+    behavior: {
+      strict_confirm: true,
+      auto_mode: false
+    }
+  };
+}
+function stringifyConfig(config) {
+  return YAML.stringify(config);
+}
+async function writeConfigYaml(filePath, config) {
+  await writeTextFile(filePath, stringifyConfig(config));
+}
+async function readConfigYaml(filePath) {
+  const content = await readFile2(filePath, "utf8");
+  return YAML.parse(content);
+}
+async function updateConfigYaml(filePath, updater) {
+  const content = await readFile2(filePath, "utf8");
+  const document = parseDocument(content);
+  const config = document.toJSON();
+  updater(config);
+  for (const [key, value] of Object.entries(config)) {
+    document.set(key, value);
+  }
+  await writeTextFile(filePath, document.toString());
+  return config;
+}
+async function addAgentsToConfig(filePath, agents) {
+  return updateConfigYaml(filePath, (config) => {
+    const merged = /* @__PURE__ */ new Set([...config.agents ?? [], ...agents]);
+    config.agents = [...merged];
+  });
+}
+async function updateHarnessVersion(filePath, version) {
+  return updateConfigYaml(filePath, (config) => {
+    config.harness_version = version;
+  });
+}
+
+// src/commands/platforms.ts
+import { cancel, confirm, multiselect } from "@clack/prompts";
+function parseAgentList(agentList) {
+  const values = agentList.split(",").map((value) => value.trim()).filter(Boolean);
+  if (values.length === 0) {
+    throw new Error("No agent platform specified.");
+  }
+  const invalid = values.filter((value) => !isAgentPlatform(value));
+  if (invalid.length > 0) {
+    throw new Error(`Unknown agent platform: ${invalid.join(", ")}`);
+  }
+  return [...new Set(values)];
+}
+async function resolvePlatforms(opts, defaults = ["claude-code"]) {
+  if (opts.agent) {
+    return parseAgentList(opts.agent);
+  }
+  if (opts.yes) {
+    return defaults;
+  }
+  let selectedDefaults = defaults;
+  while (true) {
+    const result = await multiselect({
+      message: "Select agent platforms (Space to toggle, Enter to review)",
+      options: AGENT_PLATFORMS.map((platform) => ({
+        label: PLATFORM_META[platform].label,
+        value: platform
+      })),
+      initialValues: selectedDefaults,
+      required: true
+    });
+    if (typeof result === "symbol") {
+      cancel("Platform selection cancelled.");
+      process.exit(1);
+    }
+    const labels = result.map((platform) => PLATFORM_META[platform].label).join(", ");
+    const shouldInstall = await confirm({
+      message: `Install Easy Coding for: ${labels}?`,
+      initialValue: true
+    });
+    if (typeof shouldInstall === "symbol") {
+      cancel("Platform selection cancelled.");
+      process.exit(1);
+    }
+    if (shouldInstall) {
+      return result;
+    }
+    selectedDefaults = result;
+  }
+}
+
+// src/commands/add-agent.ts
+async function addAgent(opts) {
+  renderBanner();
+  const cwd = process.cwd();
+  const configPath = path8.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  if (!await pathExists(configPath)) {
+    throw new Error("No .easy-coding/config.yaml found. Run easy-coding init first.");
+  }
+  const config = await readConfigYaml(configPath);
+  const platforms = await resolvePlatforms(opts, ["claude-code"]);
+  const toInstall = platforms.filter((platform) => !config.agents.includes(platform));
+  if (toInstall.length === 0) {
+    outro(chalk2.yellow("All selected agent platforms are already installed."));
+    return;
+  }
+  for (const platform of toInstall) {
+    await CONFIGURATORS[platform](cwd);
+  }
+  await addAgentsToConfig(configPath, toInstall);
+  outro(chalk2.green(`Added agent platforms: ${toInstall.join(", ")}`));
+}
+
+// src/commands/init.ts
+import { note, outro as outro2 } from "@clack/prompts";
+import chalk3 from "chalk";
+
+// src/utils/gitignore.ts
+import path9 from "path";
+async function ensureGitignoreEntry(cwd, entry, heading = "# \u2550\u2550\u2550 easy-coding-harness (auto-generated) \u2550\u2550\u2550\n# Personal runtime state; do not commit") {
+  const gitignorePath = path9.join(cwd, ".gitignore");
+  const current = await readTextIfExists(gitignorePath) ?? "";
+  const lines = current.split(/\r?\n/).map((line) => line.trim());
+  if (lines.includes(entry)) {
+    return false;
+  }
+  const prefix = current.trimEnd();
+  const next = [prefix, heading, entry].filter(Boolean).join("\n");
+  await writeTextFile(gitignorePath, next);
+  return true;
+}
+async function ensureEasyCodingStateIgnored(cwd) {
+  return ensureGitignoreEntry(cwd, STATE_GITIGNORE_ENTRY);
+}
+
+// src/utils/install-state.ts
+import { readdir as readdir2 } from "fs/promises";
+import path10 from "path";
+var LEGACY_ROOT_FILES = ["SOUL.md", "RULES.md", "ABSTRACT.md"];
+async function detectEasyCodingInstallState(cwd) {
+  const easyCodingDir = path10.join(cwd, EASY_CODING_DIR);
+  if (!await pathExists(easyCodingDir)) {
+    return { kind: "fresh", easyCodingDir };
+  }
+  const configPath = path10.join(easyCodingDir, CONFIG_FILE);
+  if (await pathExists(configPath)) {
+    return { kind: "installed", easyCodingDir, configPath };
+  }
+  const legacyAssets = await detectLegacyAssets(easyCodingDir);
+  if (legacyAssets.length === 0) {
+    return { kind: "unknown", easyCodingDir };
+  }
+  return {
+    kind: "legacy",
+    easyCodingDir,
+    legacyAssets,
+    missingHarnessFiles: [relativeConfigPath(), relativeProjectInitTaskPath()]
+  };
+}
+async function detectLegacyAssets(easyCodingDir) {
+  const assets = [];
+  for (const file of LEGACY_ROOT_FILES) {
+    if (await pathExists(path10.join(easyCodingDir, file))) {
+      assets.push(relativeEasyCodingPath(file));
+    }
+  }
+  if (await pathExists(path10.join(easyCodingDir, "memory", "long", "MEMORY.md"))) {
+    assets.push(relativeEasyCodingPath("memory", "long", "MEMORY.md"));
+  }
+  const shortMemoryFiles = await listMarkdownFiles(path10.join(easyCodingDir, "memory", "short"));
+  assets.push(...shortMemoryFiles.map((file) => relativeEasyCodingPath("memory", "short", file)));
+  for (const dir of ["spec", "prototype"]) {
+    if (await hasAnyDirectoryEntry(path10.join(easyCodingDir, dir))) {
+      assets.push(relativeEasyCodingPath(dir));
+    }
+  }
+  return assets.sort();
+}
+async function listMarkdownFiles(dir) {
+  if (!await isDirectory(dir)) {
+    return [];
+  }
+  const entries = await readdir2(dir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
+}
+async function hasAnyDirectoryEntry(dir) {
+  if (!await isDirectory(dir)) {
+    return false;
+  }
+  return (await readdir2(dir)).length > 0;
+}
+function relativeEasyCodingPath(...segments) {
+  return path10.posix.join(EASY_CODING_DIR, ...segments);
+}
+function relativeConfigPath() {
+  return path10.posix.join(EASY_CODING_DIR, CONFIG_FILE);
+}
+function relativeProjectInitTaskPath() {
+  return path10.posix.join(EASY_CODING_DIR, TASKS_DIR, PROJECT_INIT_TASK_ID, "task.json");
+}
+
+// src/utils/runtime-scaffold.ts
+import path11 from "path";
+async function writeRuntimeScaffold(cwd, agents) {
+  const easyCodingDir = path11.join(cwd, EASY_CODING_DIR);
+  await ensureDir(easyCodingDir);
+  const configPath = path11.join(easyCodingDir, CONFIG_FILE);
+  if (!await pathExists(configPath)) {
+    const projectName = path11.basename(cwd);
+    await writeConfigYaml(
+      configPath,
+      createDefaultConfig({ projectName, harnessVersion: VERSION, agents })
+    );
+  }
+  await ensureDir(path11.join(easyCodingDir, "tasks"));
+  await ensureDir(path11.join(easyCodingDir, SPEC_DIR, MAIN_SPEC_DIR));
+  await ensureDir(path11.join(easyCodingDir, SPEC_DIR, DEV_SPEC_DIR));
+  await writeMemoryScaffold(easyCodingDir);
+}
+async function writeMemoryScaffold(easyCodingDir) {
+  const memoryDir = path11.join(easyCodingDir, MEMORY_DIR);
+  await ensureDir(path11.join(memoryDir, "short"));
+  await ensureDir(path11.join(memoryDir, "long"));
+  for (const file of ["MEMORY.md", "BUSINESS.md", "TECHNICAL.md"]) {
+    const destination = path11.join(memoryDir, "long", file);
+    if (await pathExists(destination)) {
+      continue;
+    }
+    const templatePath = getTemplatePath("runtime", "memory", "long", file);
+    await writeTextFile(destination, await readTextFile(templatePath));
+  }
+}
+
+// src/utils/task-json.ts
+import { readdir as readdir3 } from "fs/promises";
+import path12 from "path";
+function createProjectInitTask(params) {
+  return {
+    type: "project-init",
+    status: "PENDING",
+    created_at: (params.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    created_by: "cli-init",
+    context: {
+      agents_installed: params.agents,
+      cli_version: VERSION,
+      project_path: params.cwd,
+      init_source: params.initSource ?? "fresh",
+      ...params.legacyAssets ? { legacy_assets: params.legacyAssets } : {},
+      ...params.legacyMissingHarnessFiles ? { legacy_missing_harness_files: params.legacyMissingHarnessFiles } : {}
+    },
+    init_log: []
+  };
+}
+function getTaskJsonPath(cwd, taskId) {
+  return path12.join(cwd, EASY_CODING_DIR, TASKS_DIR, taskId, "task.json");
+}
+async function writeTaskJson(filePath, task) {
+  await writeTextFile(filePath, JSON.stringify(task, null, 2));
+}
+async function readTaskJson(filePath) {
+  return JSON.parse(await readTextFile(filePath));
+}
+async function writeProjectInitTask(cwd, agents, options = {}) {
+  await writeTaskJson(
+    getTaskJsonPath(cwd, PROJECT_INIT_TASK_ID),
+    createProjectInitTask({
+      cwd,
+      agents,
+      initSource: options.initSource,
+      legacyAssets: options.legacyAssets,
+      legacyMissingHarnessFiles: options.legacyMissingHarnessFiles
+    })
+  );
+}
+async function listTasks(cwd) {
+  const tasksDir = path12.join(cwd, EASY_CODING_DIR, TASKS_DIR);
+  if (!await pathExists(tasksDir)) {
+    return [];
+  }
+  const entries = await readdir3(tasksDir, { withFileTypes: true });
+  const tasks = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const taskPath = getTaskJsonPath(cwd, entry.name);
+    if (!await pathExists(taskPath)) {
+      continue;
+    }
+    tasks.push({ id: entry.name, task: await readTaskJson(taskPath) });
+  }
+  return tasks;
+}
+function summarizeTaskStatuses(tasks) {
+  return tasks.reduce(
+    (summary, item) => {
+      summary[item.task.status] = (summary[item.task.status] ?? 0) + 1;
+      return summary;
+    },
+    {}
+  );
+}
+function isActiveTask(task) {
+  return task.status !== "COMPLETE" && task.status !== "CLOSED";
+}
+
+// src/commands/init.ts
+async function init(opts) {
+  renderBanner();
+  const cwd = process.cwd();
+  const installState = await detectEasyCodingInstallState(cwd);
+  if (installState.kind === "installed") {
+    throw new Error(
+      ".easy-coding/config.yaml already exists. Use easy-coding add-agent or easy-coding upgrade."
+    );
+  }
+  if (installState.kind === "unknown") {
+    throw new Error(
+      ".easy-coding exists but is not recognized as an easy-coding harness or legacy easy-coding skill project. Please inspect it manually before running init."
+    );
+  }
+  const platforms = await resolvePlatforms(opts, ["claude-code"]);
+  for (const platform of platforms) {
+    await CONFIGURATORS[platform](cwd);
+  }
+  await writeRuntimeScaffold(cwd, platforms);
+  await writeProjectInitTask(cwd, platforms, {
+    initSource: installState.kind === "legacy" ? "legacy-easy-coding" : "fresh",
+    legacyAssets: installState.kind === "legacy" ? installState.legacyAssets : void 0,
+    legacyMissingHarnessFiles: installState.kind === "legacy" ? installState.missingHarnessFiles : void 0
+  });
+  await ensureEasyCodingStateIgnored(cwd);
+  const triggers = platforms.map(
+    (platform) => `${PLATFORM_META[platform].label}: ${PLATFORM_META[platform].skillTrigger}ec-init`
+  ).join("\n");
+  note(triggers, "Next step");
+  outro2(chalk3.green("easy-coding harness installed. Open your agent and run ec-init."));
+}
+
+// src/commands/status.ts
+import path15 from "path";
+import chalk4 from "chalk";
+
+// src/utils/compare-versions.ts
+import path13 from "path";
+function normalize(version) {
+  const [core] = version.split("-");
+  return core.split(".").map((part) => {
+    const parsed = Number.parseInt(part, 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  });
+}
+function compareVersions(a, b) {
+  const left = normalize(a);
+  const right = normalize(b);
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left[index] ?? 0;
+    const rightPart = right[index] ?? 0;
+    if (leftPart < rightPart) return -1;
+    if (leftPart > rightPart) return 1;
+  }
+  return 0;
+}
+function isVersionBehind(installed, current = VERSION) {
+  return compareVersions(installed, current) === -1;
+}
+async function checkForUpgrade(cwd) {
+  const configPath = path13.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  if (!await pathExists(configPath)) {
+    return;
+  }
+  const config = await readConfigYaml(configPath);
+  const installed = String(config.harness_version ?? "");
+  if (installed && isVersionBehind(installed)) {
+    process.stderr.write(
+      `easy-coding harness ${installed} is older than CLI ${VERSION}. Run easy-coding upgrade when ready.
+`
+    );
+  }
+}
+
+// src/utils/state-json.ts
+import path14 from "path";
+function getStateJsonPath(cwd) {
+  return path14.join(cwd, EASY_CODING_DIR, STATE_FILE);
+}
+async function readStateJson(cwd) {
+  const content = await readTextIfExists(getStateJsonPath(cwd));
+  if (!content) {
+    return null;
+  }
+  return JSON.parse(content);
+}
+
+// src/commands/status.ts
+async function status() {
+  renderBanner();
+  const cwd = process.cwd();
+  const configPath = path15.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  if (!await pathExists(configPath)) {
+    throw new Error("No easy-coding harness found in this project.");
+  }
+  const config = await readConfigYaml(configPath);
+  const tasks = await listTasks(cwd);
+  const taskCounts = summarizeTaskStatuses(tasks);
+  const activeTasks = tasks.filter((item) => isActiveTask(item.task));
+  const state = await readStateJson(cwd);
+  const versionRelation = compareVersions(config.harness_version, VERSION);
+  console.log(chalk4.bold("Harness"));
+  console.log(`  version: ${config.harness_version}`);
+  console.log(`  cli: ${VERSION}`);
+  if (versionRelation === -1) {
+    console.log(chalk4.yellow("  upgrade: available"));
+  } else if (versionRelation === 1) {
+    console.log(chalk4.red("  upgrade: CLI is older than project harness"));
+  } else {
+    console.log("  upgrade: up to date");
+  }
+  console.log(`  agents: ${config.agents.join(", ") || "(none)"}`);
+  console.log(`  project: ${config.project.name} (${config.project.mode})`);
+  console.log("");
+  console.log(chalk4.bold("State"));
+  if (state) {
+    console.log(`  current_stage: ${state.current_stage}`);
+    console.log(`  current_task: ${state.current_task ?? "(none)"}`);
+    console.log(`  last_agent: ${state.last_agent}`);
+  } else {
+    console.log("  state.json: not created yet");
+  }
+  console.log("");
+  console.log(chalk4.bold("Tasks"));
+  console.log(`  total: ${tasks.length}`);
+  for (const [status2, count] of Object.entries(taskCounts)) {
+    console.log(`  ${status2}: ${count}`);
+  }
+  if (activeTasks.length > 0) {
+    console.log("  active:");
+    for (const item of activeTasks) {
+      console.log(`    - ${item.id}: ${item.task.status}`);
+    }
+  }
+}
+
+// src/commands/upgrade.ts
+import path16 from "path";
+import { cancel as cancel2, confirm as confirm2, outro as outro3 } from "@clack/prompts";
+import chalk5 from "chalk";
+async function upgrade(opts) {
+  renderBanner();
+  const cwd = process.cwd();
+  const configPath = path16.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  if (!await pathExists(configPath)) {
+    throw new Error("No .easy-coding/config.yaml found. Run easy-coding init first.");
+  }
+  const config = await readConfigYaml(configPath);
+  const relation = compareVersions(config.harness_version, VERSION);
+  if (relation === 0) {
+    outro3(chalk5.green(`easy-coding harness is already up to date (${VERSION}).`));
+    return;
+  }
+  if (relation === 1) {
+    throw new Error(
+      `Project harness version ${config.harness_version} is newer than CLI ${VERSION}. Update the CLI first.`
+    );
+  }
+  const summary = [
+    `Upgrade: ${config.harness_version} -> ${VERSION}`,
+    `Installed agents: ${config.agents.join(", ")}`,
+    "Will overwrite managed skills, hooks, agents, and generated main-constraint regions.",
+    "Will not touch tasks, memory, state, spec, or project knowledge files."
+  ].join("\n");
+  if (opts.dryRun) {
+    console.log(summary);
+    return;
+  }
+  if (!opts.yes) {
+    const shouldUpgrade = await confirm2({
+      message: "Apply this harness upgrade?",
+      initialValue: true
+    });
+    if (typeof shouldUpgrade === "symbol" || !shouldUpgrade) {
+      cancel2("Upgrade cancelled.");
+      return;
+    }
+  }
+  for (const platform of config.agents) {
+    await CONFIGURATORS[platform](cwd);
+  }
+  await updateHarnessVersion(configPath, VERSION);
+  outro3(chalk5.green(`easy-coding harness upgraded to ${VERSION}.`));
+}
+
+// src/cli.ts
+function withErrorHandling(fn) {
+  return async (opts) => {
+    try {
+      await fn(opts);
+    } catch (error) {
+      console.error(chalk6.red("Error:"), error instanceof Error ? error.message : error);
+      if (process.env.EC_DEBUG && error instanceof Error) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  };
+}
+await checkForUpgrade(process.cwd());
+var program = new Command();
+program.name("easy-coding").description(PACKAGE_NAME).version(VERSION, "-v, --version");
+program.command("init").description("Initialize easy-coding harness in current project").option("--agent <list>", "Comma-separated platforms: claude-code,codex,qoder").option("-y, --yes", "Skip prompts, use defaults").action(withErrorHandling(init));
+program.command("add-agent").description("Add agent platform support to an existing project").option("--agent <list>", "Comma-separated platforms to add").action(withErrorHandling(addAgent));
+program.command("upgrade").description("Upgrade harness files to current CLI version").option("--dry-run", "Preview changes without applying").option("-y, --yes", "Skip confirmation").action(withErrorHandling(upgrade));
+program.command("status").description("Show installed agents, version, and tasks").action(withErrorHandling(status));
+program.parse();
+//# sourceMappingURL=cli.js.map