@kitsy/coop 0.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Kitsy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,7 @@
+# @kitsy/coop
+
+CLI package for COOP.
+
+Commands:
+- `coop`
+

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1049 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs6 from "fs";
+import path7 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/commands/create.ts
+import fs2 from "fs";
+import path2 from "path";
+import {
+  IdeaStatus,
+  TaskStatus,
+  TaskType,
+  stringifyFrontmatter,
+  validateStructural,
+  writeTask
+} from "@kitsy/coop-core";
+
+// src/utils/prompt.ts
+import readline from "readline/promises";
+import process2 from "process";
+async function ask(question, defaultValue = "") {
+  const rl = readline.createInterface({
+    input: process2.stdin,
+    output: process2.stdout
+  });
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  rl.close();
+  return answer || defaultValue;
+}
+
+// src/utils/not-implemented.ts
+function printNotImplemented(command, phase) {
+  console.log(`${command}: Not yet implemented - coming in Phase ${phase}.`);
+}
+
+// src/utils/repo.ts
+import fs from "fs";
+import path from "path";
+import { parseTaskFile, parseYamlFile } from "@kitsy/coop-core";
+function resolveRepoRoot(start = process.cwd()) {
+  let current = path.resolve(start);
+  while (true) {
+    if (fs.existsSync(path.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return path.resolve(start);
+    }
+    current = parent;
+  }
+}
+function coopDir(root) {
+  return path.join(root, ".coop");
+}
+function ensureCoopInitialized(root) {
+  const dir = coopDir(root);
+  if (!fs.existsSync(dir)) {
+    throw new Error(`Missing .coop directory at ${dir}. Run 'coop init'.`);
+  }
+  return dir;
+}
+function readCoopConfig(root) {
+  const configPath = path.join(coopDir(root), "config.yml");
+  if (!fs.existsSync(configPath)) {
+    return { ideaPrefix: "IDEA", taskPrefix: "PM" };
+  }
+  const config = parseYamlFile(configPath);
+  const idPrefixesRaw = config.id_prefixes;
+  const idPrefixes = typeof idPrefixesRaw === "object" && idPrefixesRaw !== null ? idPrefixesRaw : {};
+  const ideaPrefix = typeof idPrefixes.idea === "string" ? idPrefixes.idea : "IDEA";
+  const taskPrefix = typeof idPrefixes.task === "string" ? idPrefixes.task : "PM";
+  return { ideaPrefix, taskPrefix };
+}
+function walkFiles(dirPath, extensions) {
+  if (!fs.existsSync(dirPath)) return [];
+  const out = [];
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...walkFiles(fullPath, extensions));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const ext = path.extname(entry.name).toLowerCase();
+    if (extensions.has(ext)) {
+      out.push(fullPath);
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+function listTaskFiles(root) {
+  return walkFiles(path.join(ensureCoopInitialized(root), "tasks"), /* @__PURE__ */ new Set([".md"]));
+}
+function listIdeaFiles(root) {
+  return walkFiles(path.join(ensureCoopInitialized(root), "ideas"), /* @__PURE__ */ new Set([".md"]));
+}
+function findTaskFileById(root, id) {
+  const target = `${id}.md`.toLowerCase();
+  const match = listTaskFiles(root).find((filePath) => path.basename(filePath).toLowerCase() === target);
+  if (!match) {
+    throw new Error(`Task '${id}' not found in .coop/tasks.`);
+  }
+  return match;
+}
+function nextNumericId(prefix, ids) {
+  const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`^${escaped}-(\\d+)$`);
+  let max = 0;
+  for (const id of ids) {
+    const match = re.exec(id);
+    if (!match) continue;
+    const value = Number(match[1]);
+    if (Number.isInteger(value) && value > max) max = value;
+  }
+  return `${prefix}-${String(max + 1).padStart(3, "0")}`;
+}
+function todayIsoDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+
+// src/commands/create.ts
+function parseCsv(value) {
+  if (!value) return [];
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function registerCreateCommand(program2) {
+  const create = program2.command("create").description("Create COOP entities");
+  create.command("task").description("Create a task").option("--id <id>", "Task id").option("--title <title>", "Task title").option("--type <type>", `Task type (${Object.values(TaskType).join(", ")})`).option("--status <status>", `Task status (${Object.values(TaskStatus).join(", ")})`).option("--track <track>", "Track id", "unassigned").option("--priority <priority>", "Task priority", "p2").option("--body <body>", "Markdown body").action(async (options) => {
+    const root = resolveRepoRoot();
+    const coop = ensureCoopInitialized(root);
+    const { taskPrefix } = readCoopConfig(root);
+    const existingIds = listTaskFiles(root).map((filePath2) => path2.basename(filePath2, ".md"));
+    const id = (options.id?.trim() || nextNumericId(taskPrefix, existingIds)).toUpperCase();
+    const title = options.title?.trim() || await ask("Task title");
+    if (!title) throw new Error("Task title is required.");
+    const typeInput = (options.type?.trim() || await ask("Task type", "feature")).toLowerCase();
+    const statusInput = (options.status?.trim() || await ask("Task status", "todo")).toLowerCase();
+    const track = options.track?.trim() || await ask("Track", "unassigned");
+    const priority = options.priority?.trim() || await ask("Priority", "p2");
+    const body = options.body ?? await ask("Task body (optional)", "");
+    const date = todayIsoDate();
+    const task = {
+      id,
+      title,
+      type: typeInput,
+      status: statusInput,
+      created: date,
+      updated: date,
+      track,
+      priority
+    };
+    const filePath = path2.join(coop, "tasks", `${id}.md`);
+    const structuralIssues = validateStructural(task, { filePath });
+    if (structuralIssues.length > 0) {
+      const message = structuralIssues.map((issue) => `- ${issue.message}`).join("\n");
+      throw new Error(`Task failed structural validation:
+${message}`);
+    }
+    writeTask(task, {
+      body,
+      filePath
+    });
+    console.log(`Created task: ${path2.relative(root, filePath)}`);
+  });
+  create.command("idea").description("Create an idea").option("--id <id>", "Idea id").option("--title <title>", "Idea title").option("--author <author>", "Idea author").option("--source <source>", "Idea source", "manual").option("--status <status>", `Idea status (${Object.values(IdeaStatus).join(", ")})`).option("--tags <tags>", "Comma-separated tags").option("--body <body>", "Markdown body").action(async (options) => {
+    const root = resolveRepoRoot();
+    const coop = ensureCoopInitialized(root);
+    const { ideaPrefix } = readCoopConfig(root);
+    const existingIds = listIdeaFiles(root).map((filePath2) => path2.basename(filePath2, ".md"));
+    const id = (options.id?.trim() || nextNumericId(ideaPrefix, existingIds)).toUpperCase();
+    const title = options.title?.trim() || await ask("Idea title");
+    if (!title) throw new Error("Idea title is required.");
+    const author = options.author?.trim() || await ask("Author", "unknown");
+    const source = options.source?.trim() || await ask("Source", "manual");
+    const status = (options.status?.trim() || await ask("Idea status", "captured")).toLowerCase();
+    const tags = options.tags ? parseCsv(options.tags) : parseCsv(await ask("Tags (comma-separated)", ""));
+    const body = options.body ?? await ask("Idea body (optional)", "");
+    const frontmatter = {
+      id,
+      title,
+      created: todayIsoDate(),
+      author,
+      status,
+      tags,
+      source,
+      linked_tasks: []
+    };
+    if (!Object.values(IdeaStatus).includes(status)) {
+      throw new Error(`Invalid idea status '${status}'.`);
+    }
+    const filePath = path2.join(coop, "ideas", `${id}.md`);
+    fs2.writeFileSync(filePath, stringifyFrontmatter(frontmatter, body), "utf8");
+    console.log(`Created idea: ${path2.relative(root, filePath)}`);
+  });
+  create.command("track").description("Create a track (Phase 2)").action(() => {
+    printNotImplemented("coop create track", 2);
+  });
+  create.command("delivery").description("Create a delivery (Phase 2)").action(() => {
+    printNotImplemented("coop create delivery", 2);
+  });
+}
+
+// src/commands/graph.ts
+import chalk from "chalk";
+import {
+  compute_readiness_with_corrections,
+  load_graph,
+  topological_sort,
+  validate_graph
+} from "@kitsy/coop-core";
+
+// src/utils/table.ts
+function formatTable(headers, rows) {
+  const table = [headers, ...rows];
+  const widths = [];
+  for (let col = 0; col < headers.length; col += 1) {
+    let width = headers[col].length;
+    for (const row of table) {
+      width = Math.max(width, (row[col] ?? "").length);
+    }
+    widths.push(width + 2);
+  }
+  return table.map((row) => row.map((cell, index) => (cell ?? "").padEnd(widths[index])).join("").trimEnd()).join("\n");
+}
+
+// src/commands/graph.ts
+function statusColor(status) {
+  switch (status) {
+    case "done":
+      return chalk.green(status);
+    case "in_progress":
+      return chalk.cyan(status);
+    case "in_review":
+      return chalk.blue(status);
+    case "blocked":
+      return chalk.yellow(status);
+    case "canceled":
+      return chalk.gray(status);
+    default:
+      return status;
+  }
+}
+function priorityRank(priority) {
+  switch (priority) {
+    case "p0":
+      return 0;
+    case "p1":
+      return 1;
+    case "p2":
+      return 2;
+    case "p3":
+      return 3;
+    default:
+      return 9;
+  }
+}
+function renderAsciiDag(tasks, order) {
+  const memo = /* @__PURE__ */ new Map();
+  const depth = (taskId) => {
+    const existing = memo.get(taskId);
+    if (existing !== void 0) return existing;
+    const task = tasks.get(taskId);
+    if (!task || !task.depends_on || task.depends_on.length === 0) {
+      memo.set(taskId, 0);
+      return 0;
+    }
+    const next = 1 + Math.max(...task.depends_on.map((depId) => depth(depId)));
+    memo.set(taskId, next);
+    return next;
+  };
+  const lines = [];
+  for (const taskId of order) {
+    const task = tasks.get(taskId);
+    if (!task) continue;
+    const indent = "  ".repeat(Math.max(0, depth(taskId)));
+    const deps = task.depends_on && task.depends_on.length > 0 ? ` <- ${task.depends_on.join(", ")}` : "";
+    lines.push(`${indent}- ${task.id} [${task.status}] ${task.title}${deps}`);
+  }
+  return lines.join("\n");
+}
+function runValidate() {
+  const root = resolveRepoRoot();
+  const graph = load_graph(coopDir(root));
+  const issues = validate_graph(graph);
+  if (issues.length === 0) {
+    console.log(chalk.green("Graph is healthy. No invariant violations found."));
+    return;
+  }
+  for (const issue of issues) {
+    const label = issue.level === "error" ? chalk.red("ERROR") : chalk.yellow("WARN");
+    const ids = issue.task_ids && issue.task_ids.length > 0 ? ` (${issue.task_ids.join(", ")})` : "";
+    console.log(`${label} [${issue.invariant}] ${issue.message}${ids}`);
+  }
+  throw new Error(`Graph validation failed with ${issues.length} issue(s).`);
+}
+function runNext() {
+  const root = resolveRepoRoot();
+  const graph = load_graph(coopDir(root));
+  const readiness = compute_readiness_with_corrections(graph);
+  const ready = [...readiness.partitions.ready].sort((a, b) => {
+    const byPriority = priorityRank(a.priority) - priorityRank(b.priority);
+    if (byPriority !== 0) return byPriority;
+    return a.id.localeCompare(b.id);
+  });
+  if (ready.length === 0) {
+    console.log("No ready tasks found.");
+  } else {
+    console.log(
+      formatTable(
+        ["ID", "Title", "Status", "Priority", "Track", "Readiness"],
+        ready.map((task) => [
+          task.id,
+          task.title,
+          statusColor(task.status),
+          task.priority ?? "-",
+          task.track ?? "-",
+          "ready"
+        ])
+      )
+    );
+  }
+  if (readiness.corrections.length > 0) {
+    console.log(`
+Corrections (${readiness.corrections.length}):`);
+    for (const correction of readiness.corrections) {
+      console.log(`- ${correction.task_id}: ${correction.from} -> ${correction.to} (${correction.reason})`);
+    }
+  }
+  if (readiness.warnings.length > 0) {
+    console.log(`
+Warnings (${readiness.warnings.length}):`);
+    for (const warning of readiness.warnings) {
+      console.log(`- ${warning.task_id}: ${warning.message}`);
+    }
+  }
+}
+function runShow() {
+  const root = resolveRepoRoot();
+  const graph = load_graph(coopDir(root));
+  const order = topological_sort(graph);
+  console.log(renderAsciiDag(graph.nodes, order));
+}
+function registerGraphCommand(program2) {
+  const graph = program2.command("graph").description("Task graph commands");
+  graph.command("validate").description("Validate graph invariants").action(() => {
+    runValidate();
+  });
+  graph.command("next").description("Show ready tasks").action(() => {
+    runNext();
+  });
+  graph.command("show").description("Render ASCII DAG").action(() => {
+    runShow();
+  });
+  graph.command("critical-path").description("Show critical path for a delivery (Phase 2)").argument("<delivery>", "Delivery name").action(() => {
+    printNotImplemented("coop graph critical-path", 2);
+  });
+}
+
+// src/commands/init.ts
+import fs4 from "fs";
+import path4 from "path";
+import { CURRENT_SCHEMA_VERSION, write_schema_version } from "@kitsy/coop-core";
+
+// src/hooks/pre-commit.ts
+import fs3 from "fs";
+import path3 from "path";
+import { spawnSync } from "child_process";
+import { detect_cycle, parseTaskContent, parseTaskFile as parseTaskFile2, validateStructural as validateStructural2 } from "@kitsy/coop-core";
+var HOOK_BLOCK_START = "# COOP_PRE_COMMIT_START";
+var HOOK_BLOCK_END = "# COOP_PRE_COMMIT_END";
+function runGit(repoRoot, args, allowFailure = false) {
+  const result = spawnSync("git", args, {
+    cwd: repoRoot,
+    encoding: "utf8"
+  });
+  const status = result.status ?? 1;
+  const stdout = result.stdout ?? "";
+  const stderr = result.stderr ?? "";
+  if (status !== 0 && !allowFailure) {
+    throw new Error(`git ${args.join(" ")} failed: ${stderr.trim() || stdout.trim() || "unknown git error"}`);
+  }
+  return { status, stdout, stderr };
+}
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function stagedTaskFiles(repoRoot) {
+  const { stdout } = runGit(repoRoot, ["diff", "--cached", "--name-only", "--diff-filter=ACMR"]);
+  return stdout.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean).map(toPosixPath).filter((entry) => entry.startsWith(".coop/tasks/") && entry.endsWith(".md"));
+}
+function readGitBlob(repoRoot, spec) {
+  const result = runGit(repoRoot, ["show", spec], true);
+  if (result.status !== 0) return null;
+  return result.stdout;
+}
+function parseTaskFromBlob(content, source) {
+  return parseTaskContent(content, source).task;
+}
+function parseStagedTasks(repoRoot, relativePaths) {
+  const errors = [];
+  const staged = [];
+  for (const relativePath of relativePaths) {
+    const absolutePath = path3.join(repoRoot, ...relativePath.split("/"));
+    const stagedBlob = readGitBlob(repoRoot, `:${relativePath}`);
+    if (!stagedBlob) {
+      errors.push(`[COOP] Unable to read staged task '${relativePath}' from git index.`);
+      continue;
+    }
+    let task;
+    try {
+      task = parseTaskFromBlob(stagedBlob, `staged:${relativePath}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`[COOP] ${message}`);
+      continue;
+    }
+    const issues = validateStructural2(task, { filePath: absolutePath });
+    for (const issue of issues) {
+      errors.push(`[COOP] ${relativePath}: ${issue.message}`);
+    }
+    staged.push({
+      relativePath,
+      absolutePath,
+      task
+    });
+  }
+  return { staged, errors };
+}
+function buildGraphForCycleCheck(tasks) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    nodes.set(task.id, task);
+  }
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const id of nodes.keys()) {
+    forward.set(id, /* @__PURE__ */ new Set());
+    reverse.set(id, /* @__PURE__ */ new Set());
+  }
+  for (const task of tasks) {
+    const deps = new Set(task.depends_on ?? []);
+    forward.set(task.id, deps);
+    for (const depId of deps) {
+      if (!nodes.has(depId)) continue;
+      reverse.get(depId)?.add(task.id);
+    }
+  }
+  return {
+    nodes,
+    forward,
+    reverse,
+    topological_order: [],
+    tracks: /* @__PURE__ */ new Map(),
+    resources: /* @__PURE__ */ new Map(),
+    deliveries: /* @__PURE__ */ new Map()
+  };
+}
+function collectTasksForCycleCheck(repoRoot, stagedTasks) {
+  const stagedByPath = /* @__PURE__ */ new Map();
+  for (const staged of stagedTasks) {
+    stagedByPath.set(toPosixPath(staged.absolutePath), staged.task);
+  }
+  const tasks = [];
+  for (const filePath of listTaskFiles(repoRoot)) {
+    const normalized = toPosixPath(path3.resolve(filePath));
+    const stagedTask = stagedByPath.get(normalized);
+    if (stagedTask) {
+      tasks.push(stagedTask);
+      continue;
+    }
+    tasks.push(parseTaskFile2(filePath).task);
+  }
+  return tasks;
+}
+function runPreCommitChecks(repoRoot) {
+  const relativeTaskFiles = stagedTaskFiles(repoRoot);
+  if (relativeTaskFiles.length === 0) {
+    return { ok: true, errors: [] };
+  }
+  const parsed = parseStagedTasks(repoRoot, relativeTaskFiles);
+  const errors = [...parsed.errors];
+  if (parsed.staged.length > 0 && errors.length === 0) {
+    try {
+      const tasks = collectTasksForCycleCheck(repoRoot, parsed.staged);
+      const graph = buildGraphForCycleCheck(tasks);
+      const cycle = detect_cycle(graph);
+      if (cycle) {
+        errors.push(`[COOP] Dependency cycle detected: ${cycle.join(" -> ")}.`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`[COOP] Failed to run dependency cycle check: ${message}`);
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors
+  };
+}
+function hookScriptBlock() {
+  return [
+    HOOK_BLOCK_START,
+    "if command -v coop >/dev/null 2>&1; then",
+    '  coop hook pre-commit --repo "$PWD" || exit $?',
+    'elif [ -x "./node_modules/.bin/coop" ]; then',
+    '  ./node_modules/.bin/coop hook pre-commit --repo "$PWD" || exit $?',
+    "elif command -v pnpm >/dev/null 2>&1; then",
+    '  pnpm -s exec coop hook pre-commit --repo "$PWD" || exit $?',
+    "else",
+    `  echo "[COOP] Unable to run pre-commit checks: 'coop' command not found."`,
+    "  exit 1",
+    "fi",
+    HOOK_BLOCK_END,
+    ""
+  ].join("\n");
+}
+function installPreCommitHook(repoRoot) {
+  const hookPath = path3.join(repoRoot, ".git", "hooks", "pre-commit");
+  const hookDir = path3.dirname(hookPath);
+  if (!fs3.existsSync(hookDir)) {
+    return {
+      installed: false,
+      hookPath,
+      message: "Skipped pre-commit hook installation (.git/hooks not found)."
+    };
+  }
+  const block = hookScriptBlock();
+  if (!fs3.existsSync(hookPath)) {
+    const content = ["#!/bin/sh", "", block].join("\n");
+    fs3.writeFileSync(hookPath, content, "utf8");
+  } else {
+    const existing = fs3.readFileSync(hookPath, "utf8");
+    if (!existing.includes(HOOK_BLOCK_START)) {
+      const suffix = existing.endsWith("\n") ? "" : "\n";
+      fs3.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
+    }
+  }
+  try {
+    fs3.chmodSync(hookPath, 493);
+  } catch {
+  }
+  return {
+    installed: true,
+    hookPath,
+    message: "Installed COOP pre-commit hook."
+  };
+}
+
+// src/commands/init.ts
+var DEFAULT_CONFIG = `version: 2
+project:
+  name: "My Project"
+  id: "my-project"
+
+id_prefixes:
+  idea: "IDEA"
+  task: "PM"
+  delivery: "DEL"
+  run: "RUN"
+
+defaults:
+  task:
+    type: feature
+    priority: p2
+    complexity: medium
+    determinism: medium
+  track: unassigned
+
+scheduling:
+  algorithm: critical-path
+  velocity_window_weeks: 4
+  overhead_factor: 1.2
+
+ai:
+  default_executor: claude-sonnet
+  sandbox: true
+  max_concurrent_agents: 4
+  token_budget_per_task: 50000
+
+plugins:
+  enabled: []
+
+hooks:
+  on_task_transition: .coop/hooks/on-task-transition.sh
+  on_delivery_complete: .coop/hooks/on-delivery-complete.sh
+`;
+var TASK_TEMPLATE = `---
+id: PM-001
+title: "Implement feature"
+type: feature
+status: todo
+created: 2026-03-06
+updated: 2026-03-06
+priority: p2
+track: unassigned
+depends_on: []
+---
+
+## Context
+Why this task exists.
+
+## Technical Notes
+Implementation details.
+
+## Open Questions
+- Question here
+`;
+var IDEA_TEMPLATE = `---
+id: IDEA-001
+title: "New idea"
+created: 2026-03-06
+author: your-name
+status: captured
+tags: []
+source: manual
+linked_tasks: []
+---
+
+## Problem
+What problem are you solving?
+
+## Hypothesis
+What do you believe will happen?
+`;
+function ensureDir(dirPath) {
+  fs4.mkdirSync(dirPath, { recursive: true });
+}
+function writeIfMissing(filePath, content) {
+  if (!fs4.existsSync(filePath)) {
+    fs4.writeFileSync(filePath, content, "utf8");
+  }
+}
+function ensureGitignoreEntry(root, entry) {
+  const gitignorePath = path4.join(root, ".gitignore");
+  if (!fs4.existsSync(gitignorePath)) {
+    fs4.writeFileSync(gitignorePath, `${entry}
+`, "utf8");
+    return;
+  }
+  const content = fs4.readFileSync(gitignorePath, "utf8");
+  const lines = content.split(/\r?\n/).map((line) => line.trim());
+  if (!lines.includes(entry)) {
+    const suffix = content.endsWith("\n") ? "" : "\n";
+    fs4.writeFileSync(gitignorePath, `${content}${suffix}${entry}
+`, "utf8");
+  }
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize .coop/ structure in the current repository").action(() => {
+    const root = resolveRepoRoot();
+    const coop = coopDir(root);
+    const dirs = [
+      "ideas",
+      "tasks",
+      "tracks",
+      "deliveries",
+      "resources",
+      "templates",
+      "plugins",
+      "hooks",
+      "runs",
+      "decisions",
+      "history/tasks",
+      "history/deliveries",
+      ".index"
+    ];
+    for (const dir of dirs) {
+      ensureDir(path4.join(coop, dir));
+    }
+    writeIfMissing(path4.join(coop, "config.yml"), DEFAULT_CONFIG);
+    if (!fs4.existsSync(path4.join(coop, "schema-version"))) {
+      write_schema_version(coop, CURRENT_SCHEMA_VERSION);
+    }
+    writeIfMissing(path4.join(coop, "templates/task.md"), TASK_TEMPLATE);
+    writeIfMissing(path4.join(coop, "templates/idea.md"), IDEA_TEMPLATE);
+    ensureGitignoreEntry(root, ".coop/.index/");
+    const hook = installPreCommitHook(root);
+    console.log("Initialized COOP workspace.");
+    console.log(`- Root: ${root}`);
+    console.log(`- ${hook.message}`);
+    if (hook.installed) {
+      console.log(`- Hook: ${path4.relative(root, hook.hookPath)}`);
+    }
+    console.log("- Next steps:");
+    console.log("  1. coop create idea");
+    console.log("  2. coop create task");
+    console.log("  3. coop graph validate");
+  });
+}
+
+// src/commands/list.ts
+import path5 from "path";
+import { parseIdeaFile, parseTaskFile as parseTaskFile3 } from "@kitsy/coop-core";
+import chalk2 from "chalk";
+function statusColor2(status) {
+  switch (status) {
+    case "done":
+      return chalk2.green(status);
+    case "in_progress":
+      return chalk2.cyan(status);
+    case "in_review":
+      return chalk2.blue(status);
+    case "blocked":
+      return chalk2.yellow(status);
+    case "canceled":
+      return chalk2.gray(status);
+    default:
+      return status;
+  }
+}
+function sortByIdAsc(items) {
+  return [...items].sort((a, b) => a.id.localeCompare(b.id));
+}
+function loadTasks(root) {
+  return listTaskFiles(root).map((filePath) => ({
+    task: parseTaskFile3(filePath).task,
+    filePath
+  }));
+}
+function loadIdeas(root) {
+  return listIdeaFiles(root).map((filePath) => ({
+    idea: parseIdeaFile(filePath).idea,
+    filePath
+  }));
+}
+function listTasks(options) {
+  const root = resolveRepoRoot();
+  ensureCoopInitialized(root);
+  const rows = loadTasks(root).filter(({ task }) => {
+    if (options.status && task.status !== options.status) return false;
+    if (options.track && (task.track ?? "unassigned") !== options.track) return false;
+    if (options.priority && (task.priority ?? "p2") !== options.priority) return false;
+    return true;
+  }).map(({ task, filePath }) => ({
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    priority: task.priority ?? "-",
+    track: task.track ?? "-",
+    filePath
+  }));
+  const sorted = sortByIdAsc(rows);
+  if (sorted.length === 0) {
+    console.log("No tasks found.");
+    return;
+  }
+  console.log(
+    formatTable(
+      ["ID", "Title", "Status", "Priority", "Track", "File"],
+      sorted.map((entry) => [
+        entry.id,
+        entry.title,
+        statusColor2(entry.status),
+        entry.priority,
+        entry.track,
+        path5.relative(root, entry.filePath)
+      ])
+    )
+  );
+  console.log(`
+Total tasks: ${sorted.length}`);
+}
+function listIdeas(options) {
+  const root = resolveRepoRoot();
+  ensureCoopInitialized(root);
+  const rows = loadIdeas(root).filter(({ idea }) => {
+    if (options.status && idea.status !== options.status) return false;
+    return true;
+  }).map(({ idea, filePath }) => ({
+    id: idea.id,
+    title: idea.title,
+    status: idea.status,
+    priority: "-",
+    track: "-",
+    filePath
+  }));
+  const sorted = sortByIdAsc(rows);
+  if (sorted.length === 0) {
+    console.log("No ideas found.");
+    return;
+  }
+  console.log(
+    formatTable(
+      ["ID", "Title", "Status", "Priority", "Track", "File"],
+      sorted.map((entry) => [
+        entry.id,
+        entry.title,
+        statusColor2(entry.status),
+        entry.priority,
+        entry.track,
+        path5.relative(root, entry.filePath)
+      ])
+    )
+  );
+  console.log(`
+Total ideas: ${sorted.length}`);
+}
+function registerListCommand(program2) {
+  const list = program2.command("list").description("List COOP entities");
+  list.command("tasks").description("List tasks").option("--status <status>", "Filter by status").option("--track <track>", "Filter by track").option("--priority <priority>", "Filter by priority").action((options) => {
+    listTasks(options);
+  });
+  list.command("ideas").description("List ideas").option("--status <status>", "Filter by status").action((options) => {
+    listIdeas(options);
+  });
+  list.command("deliveries").description("List deliveries (Phase 2)").action(() => {
+    printNotImplemented("coop list deliveries", 2);
+  });
+}
+
+// src/commands/show.ts
+import fs5 from "fs";
+import path6 from "path";
+import { parseIdeaFile as parseIdeaFile2, parseTaskFile as parseTaskFile4 } from "@kitsy/coop-core";
+function stringify(value) {
+  if (value === null || value === void 0) return "-";
+  if (Array.isArray(value)) return value.length > 0 ? value.join(", ") : "-";
+  if (typeof value === "object") return JSON.stringify(value, null, 2);
+  return String(value);
+}
+function loadComputedFromIndex(root, taskId) {
+  const indexPath = path6.join(root, ".coop", ".index", "tasks.json");
+  if (!fs5.existsSync(indexPath)) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs5.readFileSync(indexPath, "utf8"));
+  } catch {
+    return null;
+  }
+  if (Array.isArray(parsed)) {
+    const match = parsed.find((entry) => {
+      if (!entry || typeof entry !== "object") return false;
+      return entry.id === taskId;
+    });
+    if (!match || typeof match !== "object") return null;
+    const record = match;
+    const computed = record.computed;
+    return computed && typeof computed === "object" ? computed : record;
+  }
+  if (parsed && typeof parsed === "object") {
+    const record = parsed;
+    const tasks = record.tasks;
+    if (Array.isArray(tasks)) {
+      const match = tasks.find((entry) => {
+        if (!entry || typeof entry !== "object") return false;
+        return entry.id === taskId;
+      });
+      if (match && typeof match === "object") {
+        const asRecord = match;
+        const computed = asRecord.computed;
+        return computed && typeof computed === "object" ? computed : asRecord;
+      }
+    }
+    const direct = record[taskId];
+    if (direct && typeof direct === "object") {
+      return direct;
+    }
+  }
+  return null;
+}
+function showTask(taskId) {
+  const root = resolveRepoRoot();
+  const coop = ensureCoopInitialized(root);
+  const taskFile = findTaskFileById(root, taskId.toUpperCase());
+  const parsed = parseTaskFile4(taskFile);
+  const task = parsed.task;
+  const body = parsed.body.trim();
+  const computed = loadComputedFromIndex(root, task.id);
+  const lines = [
+    `Task: ${task.id}`,
+    `Title: ${task.title}`,
+    `Status: ${task.status}`,
+    `Type: ${task.type}`,
+    `Priority: ${task.priority ?? "-"}`,
+    `Track: ${task.track ?? "-"}`,
+    `Assignee: ${task.assignee ?? "-"}`,
+    `Delivery: ${task.delivery ?? "-"}`,
+    `Depends On: ${stringify(task.depends_on)}`,
+    `Tags: ${stringify(task.tags)}`,
+    `Created: ${task.created}`,
+    `Updated: ${task.updated}`,
+    `File: ${path6.relative(root, taskFile)}`,
+    "",
+    "Body:",
+    body || "-",
+    "",
+    "Computed:"
+  ];
+  if (!computed) {
+    lines.push(`index not built (${path6.relative(root, path6.join(coop, ".index", "tasks.json"))} missing)`);
+  } else {
+    for (const [key, value] of Object.entries(computed)) {
+      lines.push(`- ${key}: ${stringify(value)}`);
+    }
+  }
+  console.log(lines.join("\n"));
+}
+function findIdeaFileById(root, ideaId) {
+  const target = `${ideaId.toUpperCase()}.md`;
+  const match = listIdeaFiles(root).find((filePath) => path6.basename(filePath).toUpperCase() === target);
+  if (!match) {
+    throw new Error(`Idea '${ideaId}' not found in .coop/ideas.`);
+  }
+  return match;
+}
+function showIdea(ideaId) {
+  const root = resolveRepoRoot();
+  ensureCoopInitialized(root);
+  const ideaFile = findIdeaFileById(root, ideaId);
+  const parsed = parseIdeaFile2(ideaFile);
+  const idea = parsed.idea;
+  const body = parsed.body.trim();
+  const lines = [
+    `Idea: ${idea.id}`,
+    `Title: ${idea.title}`,
+    `Status: ${idea.status}`,
+    `Author: ${idea.author}`,
+    `Source: ${idea.source}`,
+    `Tags: ${stringify(idea.tags)}`,
+    `Linked Tasks: ${stringify(idea.linked_tasks)}`,
+    `Created: ${idea.created}`,
+    `File: ${path6.relative(root, ideaFile)}`,
+    "",
+    "Body:",
+    body || "-"
+  ];
+  console.log(lines.join("\n"));
+}
+function registerShowCommand(program2) {
+  const show = program2.command("show").description("Show detailed COOP entities");
+  show.command("task").description("Show task details").argument("<id>", "Task ID").action((id) => {
+    showTask(id);
+  });
+  show.command("idea").description("Show idea details").argument("<id>", "Idea ID").action((id) => {
+    showIdea(id);
+  });
+  show.command("delivery").description("Show delivery details (Phase 2)").argument("<name>", "Delivery name").action(() => {
+    printNotImplemented("coop show delivery", 2);
+  });
+}
+
+// src/commands/transition.ts
+import { TaskStatus as TaskStatus2, load_graph as load_graph2, parseTaskFile as parseTaskFile5, transition, validateStructural as validateStructural3, writeTask as writeTask2 } from "@kitsy/coop-core";
+function dependencyStatusMapForTask(taskId, graph) {
+  const task = graph.nodes.get(taskId);
+  const statuses = /* @__PURE__ */ new Map();
+  for (const depId of task?.depends_on ?? []) {
+    const depTask = graph.nodes.get(depId);
+    if (!depTask) continue;
+    statuses.set(depId, depTask.status);
+  }
+  return statuses;
+}
+function registerTransitionCommand(program2) {
+  const transitionCommand = program2.command("transition").description("Transition COOP entities");
+  transitionCommand.command("task").description("Transition task status").argument("<id>", "Task ID").argument("<status>", "Target status").option("--actor <actor>", "Actor performing the transition").action((id, status, options) => {
+    const target = status.toLowerCase();
+    if (!Object.values(TaskStatus2).includes(target)) {
+      throw new Error(`Invalid target status '${status}'.`);
+    }
+    const root = resolveRepoRoot();
+    const graph = load_graph2(coopDir(root));
+    const normalizedId = id.toUpperCase();
+    const existing = graph.nodes.get(normalizedId);
+    if (!existing) {
+      throw new Error(`Task '${normalizedId}' not found.`);
+    }
+    const filePath = findTaskFileById(root, normalizedId);
+    const parsed = parseTaskFile5(filePath);
+    const result = transition(parsed.task, target, {
+      actor: options.actor,
+      dependencyStatuses: dependencyStatusMapForTask(normalizedId, graph)
+    });
+    if (!result.success) {
+      throw new Error(result.error ?? "Transition failed.");
+    }
+    const structuralIssues = validateStructural3(result.task, { filePath });
+    if (structuralIssues.length > 0) {
+      const errors = structuralIssues.map((issue) => `- ${issue.message}`).join("\n");
+      throw new Error(`Updated task is structurally invalid:
+${errors}`);
+    }
+    writeTask2(result.task, {
+      body: parsed.body,
+      raw: parsed.raw,
+      filePath
+    });
+    console.log(`Updated ${result.task.id}: ${parsed.task.status} -> ${result.task.status}`);
+  });
+}
+
+// src/index.ts
+function readVersion() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const packageJsonPath = path7.resolve(path7.dirname(currentFile), "..", "package.json");
+  try {
+    const parsed = JSON.parse(fs6.readFileSync(packageJsonPath, "utf8"));
+    return parsed.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function registerPhasePlaceholder(program2, name, phase, description) {
+  program2.command(name).description(description).action(() => {
+    printNotImplemented(`coop ${name}`, phase);
+  });
+}
+var program = new Command();
+program.name("coop");
+program.version(readVersion());
+program.description("COOP CLI");
+registerInitCommand(program);
+registerCreateCommand(program);
+registerListCommand(program);
+registerShowCommand(program);
+registerTransitionCommand(program);
+registerGraphCommand(program);
+registerPhasePlaceholder(program, "plan", 2, "Planning commands");
+registerPhasePlaceholder(program, "run", 4, "Runbook execution commands");
+registerPhasePlaceholder(program, "view", 2, "View/dashboard commands");
+registerPhasePlaceholder(program, "assign", 3, "Task assignment commands");
+registerPhasePlaceholder(program, "index", 3, "Index commands");
+registerPhasePlaceholder(program, "migrate", 2, "Schema migration commands");
+registerPhasePlaceholder(program, "status", 3, "Project status dashboard");
+registerPhasePlaceholder(program, "ext", 3, "Plugin extension commands");
+var hooks = program.command("hook");
+hooks.command("pre-commit").option("--repo <path>", "Repository root", process.cwd()).action((options) => {
+  const repoRoot = options.repo ?? process.cwd();
+  const result = runPreCommitChecks(repoRoot);
+  if (!result.ok) {
+    for (const error of result.errors) {
+      console.error(error);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  if (result.errors.length === 0) {
+    console.log("[COOP] pre-commit checks passed.");
+  }
+});
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@kitsy/coop",
+  "description": "COOP command-line interface.",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kitsy/coop.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/kitsy/coop/issues"
+  },
+  "homepage": "https://github.com/kitsy/coop#readme",
+  "keywords": [
+    "coop",
+    "cli",
+    "planning",
+    "task-graph",
+    "orchestration"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "coop": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.0",
+    "@kitsy/coop-core": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "coop": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --dts --clean --out-dir dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}