@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.2

package/dist/chunk-4AK7IBVP.js

@@ -0,0 +1,915 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  external_exports,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/openspec-adapter/dist/adapter.js
+import { execFile } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/openspec-adapter/dist/results.js
+var OpenSpecRoot = external_exports.looseObject({ path: external_exports.string(), source: external_exports.string() });
+var StatusMessage = external_exports.looseObject({
+  severity: external_exports.string(),
+  code: external_exports.string(),
+  message: external_exports.string(),
+  fix: external_exports.string().optional()
+});
+var ErrorEnvelope = external_exports.looseObject({ status: external_exports.array(StatusMessage).min(1) });
+var NewChangeResult = external_exports.looseObject({
+  change: external_exports.looseObject({ id: external_exports.string(), path: external_exports.string(), schema: external_exports.string() }),
+  root: OpenSpecRoot
+});
+var ArtifactStatus = external_exports.looseObject({
+  id: external_exports.string(),
+  outputPath: external_exports.string(),
+  /** done, ready (all requirements met) or blocked. */
+  status: external_exports.string(),
+  requires: external_exports.array(external_exports.string()),
+  missingDeps: external_exports.array(external_exports.string()).optional()
+});
+var ChangeStatus = external_exports.looseObject({
+  changeName: external_exports.string(),
+  schemaName: external_exports.string(),
+  isComplete: external_exports.boolean(),
+  applyRequires: external_exports.array(external_exports.string()),
+  artifacts: external_exports.array(ArtifactStatus),
+  root: OpenSpecRoot
+});
+var ArtifactInstructions = external_exports.looseObject({
+  changeName: external_exports.string(),
+  artifactId: external_exports.string(),
+  schemaName: external_exports.string(),
+  outputPath: external_exports.string(),
+  description: external_exports.string(),
+  instruction: external_exports.string().optional(),
+  template: external_exports.string(),
+  dependencies: external_exports.array(external_exports.unknown()),
+  unlocks: external_exports.array(external_exports.string()),
+  /** openspec/config.yaml's context, for every artifact (OpenSpec 1.13+). */
+  context: external_exports.string().optional(),
+  /** openspec/config.yaml's rules for this artifact. */
+  rules: external_exports.array(external_exports.string()).optional()
+});
+var ApplyTask = external_exports.looseObject({
+  id: external_exports.string(),
+  description: external_exports.string(),
+  done: external_exports.boolean(),
+  line: external_exports.number().optional()
+});
+var ApplyInstructions = external_exports.looseObject({
+  changeName: external_exports.string(),
+  schemaName: external_exports.string(),
+  progress: external_exports.looseObject({ total: external_exports.number(), complete: external_exports.number(), remaining: external_exports.number() }),
+  tasks: external_exports.array(ApplyTask)
+});
+var ValidationIssue = external_exports.looseObject({
+  level: external_exports.enum(["ERROR", "WARNING", "INFO"]),
+  path: external_exports.string(),
+  message: external_exports.string()
+});
+var ValidationItem = external_exports.looseObject({
+  id: external_exports.string(),
+  type: external_exports.enum(["change", "spec"]),
+  valid: external_exports.boolean(),
+  issues: external_exports.array(ValidationIssue)
+});
+var ValidationReport = external_exports.looseObject({
+  items: external_exports.array(ValidationItem),
+  summary: external_exports.looseObject({
+    totals: external_exports.looseObject({ items: external_exports.number(), passed: external_exports.number(), failed: external_exports.number() })
+  })
+});
+var ChangeSummary = external_exports.looseObject({
+  name: external_exports.string(),
+  completedTasks: external_exports.number(),
+  totalTasks: external_exports.number(),
+  lastModified: external_exports.string(),
+  status: external_exports.string()
+});
+var ChangeList = external_exports.looseObject({ changes: external_exports.array(ChangeSummary) });
+var SpecSummary = external_exports.looseObject({ id: external_exports.string(), requirementCount: external_exports.number() });
+var SpecList = external_exports.looseObject({ specs: external_exports.array(SpecSummary) });
+var Scenario = external_exports.looseObject({ name: external_exports.string(), rawText: external_exports.string() });
+var Requirement = external_exports.looseObject({
+  name: external_exports.string(),
+  text: external_exports.string(),
+  scenarios: external_exports.array(Scenario)
+});
+var Delta = external_exports.looseObject({
+  spec: external_exports.string(),
+  operation: external_exports.enum(["ADDED", "MODIFIED", "REMOVED", "RENAMED"]),
+  description: external_exports.string(),
+  requirements: external_exports.array(Requirement).optional()
+});
+var ChangeDetail = external_exports.looseObject({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  deltaCount: external_exports.number(),
+  deltas: external_exports.array(Delta)
+});
+var SpecDetail = external_exports.looseObject({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  overview: external_exports.string(),
+  requirementCount: external_exports.number(),
+  requirements: external_exports.array(Requirement)
+});
+var ArchiveResult = external_exports.looseObject({
+  archive: external_exports.looseObject({
+    change: external_exports.string(),
+    archivedAs: external_exports.string(),
+    path: external_exports.string(),
+    specsUpdated: external_exports.boolean()
+  })
+});
+var SchemaInfo = external_exports.looseObject({
+  name: external_exports.string(),
+  description: external_exports.string().optional(),
+  artifacts: external_exports.array(external_exports.string()),
+  source: external_exports.string()
+});
+
+// packages/openspec-adapter/dist/adapter.js
+var __atticus_import_meta_url = __atticusUrl("packages/openspec-adapter/dist/adapter.js");
+var OPENSPEC_PINNED = "1.14.0";
+var OPENSPEC_SUPPORTED = { min: "1.13.0", maxExclusive: "2.0.0" };
+function openspecEnv(base = process.env) {
+  return {
+    ...base,
+    DO_NOT_TRACK: "1",
+    OPENSPEC_TELEMETRY: "0",
+    OPENSPEC_NO_UPDATE_CHECK: "1",
+    OPENSPEC_NO_AUTO_CONFIG: "1",
+    OPENSPEC_NO_COMPLETIONS: "1",
+    OPENSPEC_NO_ANIMATION: "1",
+    OPEN_SPEC_INTERACTIVE: "0",
+    NO_COLOR: "1",
+    FORCE_COLOR: "0",
+    CI: "1"
+  };
+}
+function bundledOpenSpecBin(here = __atticus_import_meta_url) {
+  const other = process.env.ATTICUS_OPENSPEC_BIN?.trim();
+  if (other)
+    return other;
+  const shipped = fileURLToPath(new URL("../../../vendor/@fission-ai/openspec/bin/openspec.js", here));
+  if (existsSync(shipped))
+    return shipped;
+  const require2 = createRequire(__atticus_import_meta_url);
+  const entry = require2.resolve("@fission-ai/openspec");
+  return join(dirname(dirname(entry)), "bin", "openspec.js");
+}
+async function runOpenSpecRaw(args, o) {
+  const bin = o.bin ?? bundledOpenSpecBin();
+  return new Promise((done, reject) => {
+    execFile(process.execPath, [bin, ...args], {
+      cwd: resolve(o.root),
+      env: openspecEnv(o.env),
+      timeout: o.timeoutMs ?? 6e4,
+      maxBuffer: 64 * 1024 * 1024,
+      windowsHide: true,
+      encoding: "utf8"
+    }, (err, stdout, stderr) => {
+      if (err && err.code === "ENOENT") {
+        reject(new OpenSpecError(`OpenSpec could not be started: ${err.message}`, "not_installed", args, null, stderr));
+        return;
+      }
+      done({
+        stdout,
+        stderr,
+        exitCode: err ? typeof err.code === "number" ? err.code : 1 : 0
+      });
+    });
+  });
+}
+var OpenSpecError = class extends Error {
+  code;
+  args;
+  exitCode;
+  stderr;
+  constructor(message, code, args, exitCode, stderr = "") {
+    super(message);
+    this.code = code;
+    this.args = args;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "OpenSpecError";
+  }
+};
+function compareVersions(a, b) {
+  const split = (v) => {
+    const [core = "", pre] = v.trim().replace(/^v/, "").split("-", 2);
+    return { nums: core.split(".").map((n) => Number.parseInt(n, 10) || 0), pre };
+  };
+  const x = split(a);
+  const y = split(b);
+  for (let i = 0; i < 3; i++) {
+    const d = (x.nums[i] ?? 0) - (y.nums[i] ?? 0);
+    if (d !== 0)
+      return d < 0 ? -1 : 1;
+  }
+  if (x.pre && !y.pre)
+    return -1;
+  if (!x.pre && y.pre)
+    return 1;
+  return 0;
+}
+function isSupportedVersion(v) {
+  return /^v?\d+\.\d+\.\d+$/.test(v.trim()) && compareVersions(v, OPENSPEC_SUPPORTED.min) >= 0 && compareVersions(v, OPENSPEC_SUPPORTED.maxExclusive) < 0;
+}
+function extractJson(stdout) {
+  const text = stdout.trim();
+  try {
+    return JSON.parse(text);
+  } catch {
+    const lines = text.split(/\r?\n/);
+    const start = lines.findIndex((l) => l.startsWith("{") || l.startsWith("["));
+    if (start === -1)
+      throw new Error("no JSON in OpenSpec output");
+    return JSON.parse(lines.slice(start).join("\n"));
+  }
+}
+var ID = /^[a-z0-9][a-z0-9._-]*$/;
+function checkId(what, id) {
+  if (!ID.test(id) || id.length > 120) {
+    throw new OpenSpecError(`${what} "${id}" must be a lowercase slug`, "bad_id", [], null);
+  }
+  return id;
+}
+function samePath(a, b) {
+  const real = (p) => {
+    try {
+      return realpathSync.native(p);
+    } catch {
+      return resolve(p);
+    }
+  };
+  const x = real(a);
+  const y = real(b);
+  return process.platform === "win32" ? x.toLowerCase() === y.toLowerCase() : x === y;
+}
+function createOpenSpec(options) {
+  const root = resolve(options.root);
+  const bin = options.bin ?? bundledOpenSpecBin();
+  const timeout = options.timeoutMs ?? 6e4;
+  const env = openspecEnv(options.env);
+  const run = (args) => new Promise((resolvePromise, reject) => {
+    execFile(process.execPath, [bin, ...args], {
+      cwd: root,
+      env,
+      timeout,
+      maxBuffer: 64 * 1024 * 1024,
+      windowsHide: true,
+      encoding: "utf8"
+    }, (err, stdout, stderr) => {
+      if (err && err.code === "ENOENT") {
+        reject(new OpenSpecError(`OpenSpec could not be started: ${err.message}`, "not_installed", args, null, stderr));
+        return;
+      }
+      if (err && err.killed) {
+        reject(new OpenSpecError(`OpenSpec timed out after ${timeout} ms`, "timeout", args, null, stderr));
+        return;
+      }
+      const exitCode = err ? typeof err.code === "number" ? err.code : 1 : 0;
+      resolvePromise({ stdout, stderr, exitCode });
+    });
+  });
+  async function json(args, schema, allowFailure = false) {
+    const full = [...args, "--json"];
+    const r = await run(full);
+    let data;
+    try {
+      data = extractJson(r.stdout);
+    } catch {
+      throw new OpenSpecError(`OpenSpec printed no JSON (exit ${r.exitCode}): ${(r.stderr || r.stdout).trim().slice(0, 500)}`, "bad_output", full, r.exitCode, r.stderr);
+    }
+    const parsed = schema.safeParse(data);
+    if (r.exitCode === 0 || allowFailure && parsed.success) {
+      if (!parsed.success) {
+        throw new OpenSpecError(`OpenSpec output did not match the adapter contract: ${parsed.error.message}`, "contract_mismatch", full, r.exitCode, r.stderr);
+      }
+      checkRoot(data, full);
+      return parsed.data;
+    }
+    const envelope = ErrorEnvelope.safeParse(data);
+    if (envelope.success) {
+      const first = envelope.data.status[0];
+      throw new OpenSpecError(first.message, first.code, full, r.exitCode, r.stderr);
+    }
+    throw new OpenSpecError(`OpenSpec failed (exit ${r.exitCode})`, "failed", full, r.exitCode, r.stderr);
+  }
+  function checkRoot(data, args) {
+    const reported = data?.root?.path;
+    if (typeof reported === "string" && !samePath(reported, root)) {
+      throw new OpenSpecError(`OpenSpec used ${reported} instead of ${root}; run init in the metarepo first`, "root_mismatch", args, 0);
+    }
+  }
+  const api = {
+    root,
+    async version() {
+      const r = await run(["--version"]);
+      if (r.exitCode !== 0)
+        throw new OpenSpecError("could not read OpenSpec version", "failed", ["--version"], r.exitCode, r.stderr);
+      return r.stdout.trim();
+    },
+    async assertSupported() {
+      const v = await api.version();
+      if (!isSupportedVersion(v)) {
+        throw new OpenSpecError(`OpenSpec ${v} is not supported; Atticus needs >=${OPENSPEC_SUPPORTED.min} <${OPENSPEC_SUPPORTED.maxExclusive} (tested with ${OPENSPEC_PINNED})`, "unsupported_version", ["--version"], 0);
+      }
+      return v;
+    },
+    async init() {
+      const args = ["init", "--tools", "none", "--no-animation", "--no-copilot-cloud", "."];
+      const r = await run(args);
+      if (r.exitCode !== 0) {
+        throw new OpenSpecError(`openspec init failed: ${(r.stderr || r.stdout).trim().slice(0, 500)}`, "failed", args, r.exitCode, r.stderr);
+      }
+    },
+    async newChange(id, opts = {}) {
+      const args = ["new", "change", checkId("change id", id)];
+      if (opts.description)
+        args.push("--description", opts.description);
+      if (opts.schema)
+        args.push("--schema", checkId("schema", opts.schema));
+      const r = await json(args, NewChangeResult);
+      return { id: r.change.id, path: r.change.path, schema: r.change.schema };
+    },
+    status: async (change) => json(["status", "--change", checkId("change id", change)], ChangeStatus),
+    instructions: async (artifact, change) => json(["instructions", checkId("artifact", artifact), "--change", checkId("change id", change)], ArtifactInstructions),
+    applyInstructions: async (change) => json(["instructions", "apply", "--change", checkId("change id", change)], ApplyInstructions),
+    async validate(opts = {}) {
+      const args = ["validate"];
+      if (opts.item)
+        args.push(checkId("item", opts.item));
+      else
+        args.push("--all");
+      if (opts.type)
+        args.push("--type", opts.type);
+      if (opts.strict)
+        args.push("--strict");
+      args.push("--no-interactive");
+      return json(args, ValidationReport, true);
+    },
+    async listChanges() {
+      return (await json(["list"], ChangeList)).changes;
+    },
+    async listSpecs() {
+      return (await json(["list", "--specs"], SpecList)).specs;
+    },
+    showChange: async (id) => json(["show", checkId("change id", id), "--type", "change"], ChangeDetail),
+    showSpec: async (id) => json(["show", checkId("spec id", id), "--type", "spec"], SpecDetail),
+    async archive(id, opts = {}) {
+      checkId("change id", id);
+      if (opts.requireTasksComplete !== false) {
+        const change = (await api.listChanges()).find((c) => c.name === id);
+        if (!change)
+          throw new OpenSpecError(`Change '${id}' not found`, "change_error", ["list"], 1);
+        if (change.completedTasks < change.totalTasks) {
+          throw new OpenSpecError(`Change '${id}' has ${change.totalTasks - change.completedTasks} unfinished task(s); finish or remove them before archiving`, "tasks_incomplete", ["archive", id], null);
+        }
+      }
+      const args = ["archive", id, "--yes"];
+      if (opts.skipSpecs)
+        args.push("--skip-specs");
+      return (await json(args, ArchiveResult)).archive;
+    },
+    async schemas() {
+      return json(["schemas"], external_exports.array(SchemaInfo));
+    }
+  };
+  return api;
+}
+
+// packages/openspec-adapter/dist/org-flow.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var ORG_FLOW = "org-flow";
+var ORG_FLOW_VERSION = 2;
+var ARTIFACTS = [
+  {
+    id: "proposal",
+    generates: "proposal.md",
+    description: "Why the change is needed and what it changes: the brief placed against the estate",
+    requires: [],
+    stage: "feature",
+    instruction: `Generated by the feature stage (atticus change feature) from brief.md and feature.yaml;
+edit feature.yaml and run the stage again, never proposal.md. brief.md is the product owner's source:
+add no scope it does not ask for, and raise anything unclear as a question to its owner.
+
+- Why: the problem in the brief, in one or two sentences.
+- What Changes: the feature in plain words, each flow it changes, and each new flow.
+- Capabilities: the flows the change adds or changes; each becomes specs/<capability>/spec.md.
+- Impact: the repos and systems the flows run in, and the gaps that need decisions.
+- Open questions: what the brief leaves undecided.`,
+    template: `# Proposal
+
+## Why
+
+<!-- The problem or opportunity, and why now. -->
+
+## What Changes
+
+- <!-- Specific change. Mark breaking changes with **BREAKING**. -->
+
+## Capabilities
+
+### New Capabilities
+- \`<capability>\`: <!-- what it covers -->
+
+### Modified Capabilities
+- \`<existing-capability>\`: <!-- what requirement changes -->
+
+## Impact
+
+<!-- Repos, systems, APIs, data, consumers. -->
+
+## Open questions
+
+- <!-- Question \u2014 who should answer -->
+`
+  },
+  {
+    id: "design",
+    generates: "design.md",
+    description: "How the change is built: target flows, interface and data changes, deploy order, rollout and rollback",
+    requires: ["proposal"],
+    stage: "architecture",
+    instruction: `Generated by the architecture stage (atticus change architecture) from target-flows/;
+edit the target flows and run the stage again. Every step of a target flow is placed in the code it
+changes (at), the new file it creates (new) or the code it calls (uses), cited from verified facts.
+
+design.md covers: each target flow and what it changes; the flows read unchanged; interface changes
+with their consumers; data changes with their migrations; the deploy order across repos; and Rollout
+and rollback: how each store write and migration is undone, or why it needs no undo (an expand-only
+migration), and what happens to rows written in between.`,
+    template: `# Design
+
+## Target flows
+
+## Interface changes
+
+## Data changes
+
+## Deploy order
+
+## Rollout and rollback
+
+| Store or migration | How it is undone | Rows written in between |
+| --- | --- | --- |
+|  |  |  |
+`
+  },
+  {
+    id: "stories",
+    generates: "stories.md",
+    description: "Index of user stories; each story lives in stories/<story-id>.md",
+    requires: ["design"],
+    stage: "stories",
+    instruction: `Generated by the stories stage (atticus plan stories): one story per target flow, at
+stories/<story-id>.md, and stories.md as the index. A story says who wants what and why, its tasks
+(each once: where the code goes, the files, the criteria that accept it), its acceptance criteria in
+Given/When/Then form, its interface and data changes, non-functional needs, tests, dependencies and
+definition of done. Each task's prompt for Copilot or Claude Code is a file of its own,
+tasks/<story>.<task>.prompt.md. A story without acceptance criteria is not ready.`,
+    template: `# Stories
+
+| Story | Title | Repos | Depends on |
+| --- | --- | --- | --- |
+| <!-- s1 --> |  |  |  |
+`
+  },
+  {
+    id: "specs",
+    generates: "specs/**/*.md",
+    description: "Behaviour the change adds, modifies or removes, as OpenSpec delta specs generated from the stories",
+    requires: ["stories"],
+    stage: "stories",
+    instruction: `Generated by the stories stage from the stories' acceptance criteria, with no model
+call: one capability per flow (specs/<capability>/spec.md), a requirement per story with SHALL
+wording, and a scenario per criterion (WHEN/THEN). A capability already in openspec/specs is
+MODIFIED, carrying its archived scenarios; a removed flow's requirements are REMOVED. The stage
+runs openspec validate --strict on them; edit the stories, never the specs.`,
+    template: `## ADDED Requirements
+
+### Requirement: <!-- name -->
+The system SHALL <!-- behaviour -->.
+
+#### Scenario: <!-- name -->
+- **WHEN** <!-- condition -->
+- **THEN** <!-- outcome -->
+`
+  },
+  {
+    id: "tasks",
+    generates: "tasks.md",
+    description: "Implementation checklist grouped by repo, numbered per story",
+    requires: ["stories"],
+    stage: "stories",
+    instruction: `Generated by the stories stage: one "## <repo-id>" heading per repo, and under it a
+checkbox "- [ ] <story>.<task> <title> (story <story-id>)" per task, numbered per story without gaps,
+each small enough for one pull request. Tick a task when its tests pass; openspec counts the boxes.`,
+    template: `# Tasks
+
+## <!-- repo-id -->
+
+- [ ] 1.1 <!-- task (story s1) -->
+`
+  }
+];
+function orgFlowSchema() {
+  return {
+    name: ORG_FLOW,
+    version: ORG_FLOW_VERSION,
+    description: "Atticus 2 change flow - proposal (feature) \u2192 design (architecture) \u2192 stories \u2192 specs, tasks",
+    artifacts: ARTIFACTS.map((a) => ({
+      id: a.id,
+      generates: a.generates,
+      description: a.description,
+      template: `${a.id}.md`,
+      instruction: a.instruction + "\n",
+      requires: a.requires
+    })),
+    apply: {
+      requires: ["tasks"],
+      tracks: "tasks.md",
+      instruction: "Run one task at a time with atticus task <change> <task>, in the change's worktrees, in task order. Tick each task in tasks.md when its tests pass. Stop and ask when a task conflicts with the specs or design.\n"
+    }
+  };
+}
+var ORG_FLOW_ARTIFACTS = ARTIFACTS.map((a) => a.id);
+var ARTIFACT_STAGE = Object.fromEntries(ARTIFACTS.map((a) => [a.id, a.stage]));
+var artifactsOfStage = (stage) => ARTIFACTS.filter((a) => a.stage === stage).map((a) => a.id);
+var ORG_FLOW_V1_ONLY = ["interfaces", "mappings", "data", "snow"];
+async function orgFlowVersionOf(root) {
+  const text = await readFile(join2(root, "openspec", "schemas", ORG_FLOW, "schema.yaml"), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  try {
+    const v = (0, import_yaml.parse)(text)?.version;
+    return typeof v === "number" ? v : 1;
+  } catch {
+    return 1;
+  }
+}
+async function writeOrgFlowSchema(root) {
+  const dir = join2(root, "openspec", "schemas", ORG_FLOW);
+  await mkdir(join2(dir, "templates"), { recursive: true });
+  const header = "# Generated by Atticus from the org pack. Do not edit; change org-pack/process and regenerate.\n";
+  await writeFile(join2(dir, "schema.yaml"), header + (0, import_yaml.stringify)(orgFlowSchema(), { lineWidth: 0 }), "utf8");
+  for (const a of ARTIFACTS) {
+    await writeFile(join2(dir, "templates", `${a.id}.md`), a.template, "utf8");
+  }
+  for (const id of ORG_FLOW_V1_ONLY)
+    await rm(join2(dir, "templates", `${id}.md`), { force: true });
+  return dir;
+}
+async function setDefaultSchema(root, schema) {
+  const path = join2(root, "openspec", "config.yaml");
+  let text = "";
+  try {
+    text = await readFile(path, "utf8");
+  } catch {
+  }
+  const doc = (0, import_yaml.parseDocument)(text);
+  doc.set("schema", schema);
+  await writeFile(path, doc.toString({ lineWidth: 0 }), "utf8");
+}
+
+// packages/openspec-adapter/dist/stores.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { execFile as execFile2 } from "node:child_process";
+import { mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var STORE_MARKER_DIR = ".openspec-store";
+var STORE_MARKER = `${STORE_MARKER_DIR}/store.yaml`;
+var STORE_MARKER_VERSION = 1;
+var KEBAB = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function storeIdOf(name) {
+  const id = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return id && KEBAB.test(id) ? id : void 0;
+}
+function storeMarkerText(m) {
+  if (!KEBAB.test(m.id))
+    throw new Error(`"${m.id}" can't be an OpenSpec store id: it must be kebab-case (lowercase letters, numbers, single hyphens)`);
+  return (0, import_yaml2.stringify)({
+    version: STORE_MARKER_VERSION,
+    id: m.id,
+    ...m.remote ? { remote: m.remote } : {}
+  });
+}
+function parseStoreMarker(text) {
+  let raw;
+  try {
+    raw = (0, import_yaml2.parse)(text);
+  } catch (e) {
+    return { notes: [`store.yaml isn't YAML: ${e.message.split("\n")[0]}`] };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return { notes: ["store.yaml isn't a mapping"] };
+  const o = raw;
+  const notes = [];
+  if (o.version !== STORE_MARKER_VERSION)
+    notes.push(`store.yaml is version ${String(o.version ?? "(none)")}, newer than the version ${STORE_MARKER_VERSION} Atticus knows; read its id and remote only (the store format is beta)`);
+  if (typeof o.id !== "string" || !o.id)
+    return { notes: [...notes, "store.yaml has no id"] };
+  return {
+    marker: {
+      id: o.id,
+      ...typeof o.remote === "string" && o.remote ? { remote: o.remote } : {}
+    },
+    notes
+  };
+}
+async function readStoreMarker(dir) {
+  let text;
+  try {
+    text = await readFile2(join3(dir, STORE_MARKER_DIR, "store.yaml"), "utf8");
+  } catch {
+    return { missing: true, notes: [] };
+  }
+  return { ...parseStoreMarker(text), missing: false };
+}
+async function writeStoreMarker(dir, m) {
+  const text = storeMarkerText(m);
+  const have = await readStoreMarker(dir);
+  if (!have.missing)
+    return {
+      action: have.marker?.id === m.id ? "present" : "differs",
+      ...have.marker ? { marker: have.marker } : {}
+    };
+  await mkdir2(join3(dir, STORE_MARKER_DIR), { recursive: true });
+  await writeFile2(join3(dir, STORE_MARKER_DIR, "store.yaml"), text, {
+    encoding: "utf8",
+    flag: "wx"
+  });
+  return { action: "created", marker: { id: m.id, ...m.remote ? { remote: m.remote } : {} } };
+}
+function addStoreReference(text, ref) {
+  const parsed = (0, import_yaml2.parseDocument)(text);
+  if (parsed.errors.length)
+    return {
+      problem: `openspec/config.yaml isn't YAML: ${parsed.errors[0].message.split("\n")[0]}`
+    };
+  const doc = parsed;
+  if (doc.contents === null || doc.contents === void 0)
+    doc.contents = doc.createNode({});
+  if (!(0, import_yaml2.isMap)(doc.contents))
+    return { problem: "openspec/config.yaml isn't a mapping; left as it is" };
+  const entry = ref.remote ? { id: ref.id, remote: ref.remote } : ref.id;
+  const list = doc.get("references", true);
+  if (list === void 0 || list === null || (0, import_yaml2.isScalar)(list) && list.value === null) {
+    doc.set("references", doc.createNode([entry]));
+    return { text: doc.toString(), action: "added" };
+  }
+  if (!(0, import_yaml2.isSeq)(list))
+    return { problem: "references: in openspec/config.yaml isn't a list; left as it is" };
+  const idOf = (item) => (0, import_yaml2.isScalar)(item) ? item.value : (0, import_yaml2.isMap)(item) ? item.get("id") : void 0;
+  if (list.items.some((i) => idOf(i) === ref.id))
+    return { text, action: "present" };
+  list.add(doc.createNode(entry));
+  return { text: doc.toString(), action: "added" };
+}
+var isDir = (p) => stat(p).then((s) => s.isDirectory(), () => false);
+async function subdirs(dir) {
+  try {
+    return (await readdir(dir, { withFileTypes: true })).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name).sort();
+  } catch {
+    return [];
+  }
+}
+function purposeLine(markdown) {
+  let fence;
+  let inPurpose = false;
+  for (const line of markdown.split(/\r?\n/)) {
+    const f = /^\s*(```|~~~)/.exec(line);
+    if (f) {
+      if (fence === void 0)
+        fence = f[1];
+      else if (f[1] === fence)
+        fence = void 0;
+      continue;
+    }
+    if (fence !== void 0)
+      continue;
+    const h = /^#{1,6}\s+(.*?)(?:\s+#+)?\s*$/.exec(line);
+    if (h) {
+      if (inPurpose)
+        return void 0;
+      inPurpose = h[1].trim().toLowerCase() === "purpose";
+      continue;
+    }
+    if (inPurpose && line.trim())
+      return line.trim();
+  }
+  return void 0;
+}
+async function readStore(dir) {
+  const view = { dir, changes: [], specs: [], notes: [] };
+  if (!await isDir(dir)) {
+    view.notes.push(`${dir} isn't there`);
+    return view;
+  }
+  const m = await readStoreMarker(dir);
+  if (m.missing)
+    view.notes.push(`no ${STORE_MARKER}: read as a plain OpenSpec folder`);
+  view.notes.push(...m.notes);
+  if (m.marker) {
+    view.id = m.marker.id;
+    if (m.marker.remote)
+      view.remote = m.marker.remote;
+  }
+  const os = join3(dir, "openspec");
+  if (!await isDir(os)) {
+    view.notes.push("no openspec/ folder: nothing to read");
+    return view;
+  }
+  for (const id of await subdirs(join3(os, "changes"))) {
+    if (id === "archive")
+      continue;
+    const cdir = join3(os, "changes", id);
+    const proposal = await readFile2(join3(cdir, "proposal.md"), "utf8").catch(() => "");
+    const title = /^#\s+(.+?)\s*#*\s*$/m.exec(proposal)?.[1];
+    const tasks = await readFile2(join3(cdir, "tasks.md"), "utf8").catch(() => void 0);
+    const boxes = tasks ? [...tasks.matchAll(/^\s*[-*]\s+\[([ xX])\]/gm)].map((x) => x[1]) : [];
+    view.changes.push({
+      id,
+      ...title ? { title } : {},
+      ...boxes.length ? { tasks: { done: boxes.filter((b) => b !== " ").length, total: boxes.length } } : {},
+      dir: cdir
+    });
+  }
+  for (const id of await subdirs(join3(os, "specs"))) {
+    const file = join3(os, "specs", id, "spec.md");
+    const text = await readFile2(file, "utf8").catch(() => void 0);
+    if (text === void 0)
+      continue;
+    const purpose = purposeLine(text);
+    view.specs.push({ id, ...purpose ? { purpose } : {}, file });
+  }
+  return view;
+}
+function openspecHasStores(o = {}) {
+  return new Promise((done) => {
+    let bin;
+    try {
+      bin = o.bin ?? bundledOpenSpecBin();
+    } catch {
+      done(false);
+      return;
+    }
+    execFile2(process.execPath, [bin, "store", "--help"], {
+      env: openspecEnv(o.env),
+      timeout: o.timeoutMs ?? 3e4,
+      windowsHide: true,
+      encoding: "utf8"
+    }, (err, stdout) => done(!err && /\bregister\b/.test(stdout)));
+  });
+}
+
+// packages/openspec-adapter/dist/features.js
+import { execFile as execFile3 } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+var BETA_FEATURES = [
+  "store",
+  "store list",
+  "store doctor",
+  "workset",
+  "context",
+  "doctor",
+  "schema",
+  "schemas"
+];
+var cache = /* @__PURE__ */ new Map();
+function help(bin, args, env) {
+  return new Promise((done) => {
+    execFile3(process.execPath, [bin, ...args, "--help"], { env: openspecEnv(env), timeout: 3e4, windowsHide: true, encoding: "utf8" }, (err, stdout) => done(err ? "" : stdout));
+  });
+}
+function commandsIn(text) {
+  const at = text.search(/^Commands:\s*$/m);
+  if (at < 0)
+    return [];
+  const out = [];
+  for (const l of text.slice(at).split(/\r?\n/).slice(1)) {
+    const m = /^ {2}([a-z][a-z0-9-]*)(?:\|[a-z0-9-]+)?\b/.exec(l);
+    if (m)
+      out.push(m[1]);
+  }
+  return out;
+}
+function openspecFeatures(o = {}) {
+  const bin = o.bin ?? bundledOpenSpecBin();
+  const had = cache.get(bin);
+  if (had)
+    return had;
+  const p = (async () => {
+    const top = commandsIn(await help(bin, [], o.env));
+    const has = (c) => top.includes(c);
+    const sub = async (c) => has(c) ? await help(bin, [c], o.env) : "";
+    const [store, ctx, doctor, workset] = await Promise.all([
+      sub("store"),
+      sub("context"),
+      sub("doctor"),
+      sub("workset")
+    ]);
+    const storeCmds = commandsIn(store);
+    const storeList = storeCmds.includes("list") ? await help(bin, ["store", "list"], o.env) : "";
+    const storeDoctor = storeCmds.includes("doctor") ? await help(bin, ["store", "doctor"], o.env) : "";
+    const json = (t) => /--json\b/.test(t);
+    const beta = {
+      store: { present: has("store"), json: false },
+      "store list": { present: storeCmds.includes("list"), json: json(storeList) },
+      "store doctor": { present: storeCmds.includes("doctor"), json: json(storeDoctor) },
+      workset: { present: has("workset"), json: json(workset) },
+      context: { present: has("context"), json: json(ctx) },
+      doctor: { present: has("doctor"), json: json(doctor) },
+      schema: { present: has("schema"), json: false },
+      schemas: { present: has("schemas"), json: true }
+    };
+    return { commands: top, beta };
+  })();
+  cache.set(bin, p);
+  return p;
+}
+async function readStoreVia(dir, o = {}) {
+  const files = await readStore(dir);
+  if (!existsSync2(join4(dir, "openspec")))
+    return { ...files, via: "files" };
+  try {
+    const os = createOpenSpec({
+      root: dir,
+      ...o.bin ? { bin: o.bin } : {},
+      ...o.env ? { env: o.env } : {}
+    });
+    const changes = await os.listChanges();
+    const specs = await os.listSpecs();
+    return {
+      ...files,
+      changes: await Promise.all(changes.map(async (c) => {
+        const title = await os.showChange(c.name).then((d) => d.title).catch(() => void 0);
+        return {
+          id: c.name,
+          ...title && title !== c.name ? { title } : {},
+          ...c.totalTasks ? { tasks: { done: c.completedTasks, total: c.totalTasks } } : {},
+          dir: files.changes.find((x) => x.id === c.name)?.dir ?? join4(dir, "openspec", "changes", c.name)
+        };
+      })),
+      specs: specs.map((s) => {
+        const f = files.specs.find((x) => x.id === s.id);
+        return {
+          id: s.id,
+          ...f?.purpose ? { purpose: f.purpose } : {},
+          file: f?.file ?? join4(dir, "openspec", "specs", s.id, "spec.md")
+        };
+      }),
+      via: "openspec"
+    };
+  } catch (e) {
+    return {
+      ...files,
+      notes: [
+        ...files.notes,
+        `read from its files: openspec list couldn't run (${e.message.split("\n")[0]})`
+      ],
+      via: "files"
+    };
+  }
+}
+
+export {
+  OPENSPEC_PINNED,
+  runOpenSpecRaw,
+  isSupportedVersion,
+  createOpenSpec,
+  ORG_FLOW,
+  ORG_FLOW_VERSION,
+  ARTIFACT_STAGE,
+  artifactsOfStage,
+  orgFlowVersionOf,
+  writeOrgFlowSchema,
+  setDefaultSchema,
+  STORE_MARKER,
+  storeIdOf,
+  readStoreMarker,
+  writeStoreMarker,
+  addStoreReference,
+  openspecHasStores,
+  BETA_FEATURES,
+  openspecFeatures,
+  readStoreVia
+};