@maycombhq/openspec-adapter 0.0.0-stage → 2.0.0-beta.1

package/dist/org-flow.js

@@ -0,0 +1,286 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseDocument, stringify } from "yaml";
+/**
+ * The org-flow workflow schema: OpenSpec's own schema format, written into the metarepo at
+ * openspec/schemas/org-flow/. It extends spec-driven with the artifacts an enterprise
+ * change needs, in this dependency order:
+ *
+ *   proposal → specs, interfaces → mappings, data → design → stories → tasks → snow
+ *
+ * Files Atticus owns that are not schema artifacts (brief.md, stories/<id>.md, ux.md,
+ * repos.yaml, review/) live in the same change folder; OpenSpec ignores them.
+ *
+ * Organisations change instructions and templates through the org pack (process/), which
+ * regenerates this folder; nobody edits it by hand.
+ */
+export const ORG_FLOW = "org-flow";
+const ARTIFACTS = [
+    {
+        id: "proposal",
+        generates: "proposal.md",
+        description: "Why the change is needed and what it changes, drafted from the PO's brief",
+        requires: [],
+        instruction: `Write the proposal from brief.md in this change folder. brief.md is the product owner's
+source; do not add scope it does not ask for, and list anything unclear under Open questions.
+
+Sections:
+- Why: the problem or opportunity in one or two sentences, and why now.
+- What Changes: specific bullets. Mark breaking changes with **BREAKING**.
+- Capabilities: new and modified capabilities. Each becomes specs/<capability>/spec.md.
+  Run \`openspec list --specs\` first and reuse existing capability names.
+- Systems: every system the change touches, by catalog id, and whether it is new, modified or retired.
+- Impact: affected APIs, data, consumers, teams and external parties.
+- Open questions: what the brief leaves undecided, each with who should answer.
+
+A change that alters no behaviour sets skip_specs: true in .openspec.yaml instead of inventing requirements.`,
+        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 -->
+
+## Systems
+
+| System (catalog id) | New, modified or retired | Why |
+| --- | --- | --- |
+|  |  |  |
+
+## Impact
+
+<!-- APIs, data, consumers, teams, external parties. -->
+
+## Open questions
+
+- <!-- Question — who should answer -->
+`,
+    },
+    {
+        id: "specs",
+        generates: "specs/**/*.md",
+        description: "Behaviour the change adds, modifies or removes, as OpenSpec delta specs",
+        requires: ["proposal"],
+        instruction: `Write one delta spec per capability in the proposal, at specs/<capability>/spec.md.
+Use OpenSpec delta headers (## ADDED Requirements, ## MODIFIED Requirements, ## REMOVED Requirements,
+## RENAMED Requirements). Every requirement uses SHALL or MUST and has at least one
+"#### Scenario:" with WHEN and THEN bullets. Specs describe observable behaviour: inputs, outputs,
+errors, limits. No class names, libraries or step-by-step plans.`,
+        template: `## ADDED Requirements
+
+### Requirement: <!-- name -->
+The system SHALL <!-- behaviour -->.
+
+#### Scenario: <!-- name -->
+- **WHEN** <!-- condition -->
+- **THEN** <!-- outcome -->
+`,
+    },
+    {
+        id: "interfaces",
+        generates: "interfaces.md",
+        description: "Every integration hop the change adds, changes or retires",
+        requires: ["proposal"],
+        instruction: `List every hop between systems that the change adds, modifies or retires. Start from the
+catalog: an existing hop keeps its interface id. For each hop give caller, callee, the integration
+pattern code from the org pack's pattern registry, the operation (method and path, or topic), the
+contract (OpenAPI, AsyncAPI, schema or vendor spec), and its status: planned-new, planned-modify or
+planned-retire. A hop through the gateway names the gateway route. Never invent a pattern code; if
+none fits, write "none fits" and say why. Hops are reconciled against the architect's diagram.`,
+        template: `# Interfaces
+
+| Interface id | Caller | Callee | Pattern | Operation | Contract | Status |
+| --- | --- | --- | --- | --- | --- | --- |
+| <!-- if-… or new --> |  |  |  | <!-- GET /path or topic --> |  | planned-new |
+
+## Notes
+
+<!-- Auth, timeouts and retries per hop, consumers affected by modified or retired hops. -->
+`,
+    },
+    {
+        id: "mappings",
+        generates: "mappings.md",
+        description: "Field-level mappings for each new or changed interface",
+        requires: ["interfaces"],
+        instruction: `For each new or modified interface in interfaces.md, map every field from source to target:
+source field, target field, transformation or rule, and what happens when the source is missing or
+invalid. Use the glossary's business terms and catalog field names. Note sensitive fields and how
+they are protected. An interface with no payload change says "No mapping change".`,
+        template: `# Mappings
+
+## <!-- interface id or name -->
+
+| Source field | Target field | Rule or transformation | When missing or invalid |
+| --- | --- | --- | --- |
+|  |  |  |  |
+`,
+    },
+    {
+        id: "data",
+        generates: "data.md",
+        description: "Database and data changes: tables, columns, indexes, migrations, retention",
+        requires: ["interfaces"],
+        instruction: `Describe every data change against the current database design in the catalog: new or
+changed tables, columns (type, nullability, default), indexes and constraints, the migrations that
+make them, backfill and its size, data classification, retention and who else reads or writes the
+tables. Destructive changes need an expand-and-contract plan. A change with no data impact says
+"No data change" and why.`,
+        template: `# Data
+
+## Changes
+
+| Data store | Table | Change | Migration |
+| --- | --- | --- | --- |
+|  |  |  |  |
+
+## Backfill, classification and retention
+
+<!-- Size and duration of any backfill; classification of new fields; retention. -->
+
+## Other readers and writers
+
+<!-- From the catalog: who else uses these tables, and what they need to know. -->
+`,
+    },
+    {
+        id: "design",
+        generates: "design.md",
+        description: "How the change is built: approach, decisions, non-functional design, rollout",
+        requires: ["specs", "mappings", "data"],
+        instruction: `Explain how the change will be built. Cover: approach per system; decisions with the options
+considered; non-functional design (timeouts, retries, idempotency, capacity, security, observability)
+checked against the catalog's current settings and the platform's obligations; rollout order across
+repos, feature flags and rollback; and risks. Reference interfaces, mappings and data by id rather
+than repeating them.`,
+        template: `# Design
+
+## Approach
+
+## Decisions
+
+| Decision | Options considered | Chosen because |
+| --- | --- | --- |
+|  |  |  |
+
+## Non-functional design
+
+<!-- Timeouts, retries, idempotency, capacity, security, observability. -->
+
+## Rollout and rollback
+
+## Risks
+`,
+    },
+    {
+        id: "stories",
+        generates: "stories.md",
+        description: "Index of user stories; each story lives in stories/<story-id>.md",
+        requires: ["design"],
+        instruction: `Break the change into user stories, one file per story at stories/<story-id>.md, and keep
+stories.md as the index (Atticus regenerates it from the story files). Each story has a title in
+"As a … I want … so that …" form, acceptance criteria in Given/When/Then form that trace to spec
+scenarios, the systems and repos it touches, and its dependencies. A story without acceptance
+criteria is not ready.`,
+        template: `# Stories
+
+| Story | Title | Repos | Depends on |
+| --- | --- | --- | --- |
+| <!-- s1 --> |  |  |  |
+`,
+    },
+    {
+        id: "tasks",
+        generates: "tasks.md",
+        description: "Implementation checklist grouped by repo",
+        requires: ["stories"],
+        instruction: `List implementation tasks grouped by repo, one "## <repo-id>" heading per repo from repos.yaml.
+Each task is a checkbox "- [ ] <n>.<m> <description>" small enough for one pull request, names the
+story it serves, and includes its tests. Order tasks so dependencies come first across repos.`,
+        template: `# Tasks
+
+## <!-- repo-id -->
+
+- [ ] 1.1 <!-- task (story s1) -->
+`,
+    },
+    {
+        id: "snow",
+        generates: "snow.md",
+        description: "Service-desk requests the change needs: firewall, access, certificates, change tickets",
+        requires: ["tasks"],
+        instruction: `List every service-desk request the change needs before it can go live: firewall rules,
+access grants, certificates, DNS, secrets and the change ticket itself. Use the org pack's request
+templates and fill each field from the catalog and the design (source, destination, port, environment,
+justification). Each request names the task it unblocks. A change that needs none says "No requests".`,
+        template: `# Service-desk requests
+
+## <!-- request type, e.g. firewall rule -->
+
+| Field | Value |
+| --- | --- |
+| Environment |  |
+| Justification |  |
+| Unblocks task |  |
+`,
+    },
+];
+/** The schema.yaml content, as data. */
+export function orgFlowSchema() {
+    return {
+        name: ORG_FLOW,
+        version: 1,
+        description: "Enterprise change flow - proposal → specs, interfaces → mappings, data → design → stories → tasks → snow",
+        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: "Work in the change's worktrees, one repo at a time, in task order. Tick each task when its tests pass. Stop and ask when a task conflicts with the specs or design.\n",
+        },
+    };
+}
+export const ORG_FLOW_ARTIFACTS = ARTIFACTS.map((a) => a.id);
+/** Write openspec/schemas/org-flow/ (schema.yaml and templates/). Overwrites: the folder is generated. */
+export async function writeOrgFlowSchema(root) {
+    const dir = join(root, "openspec", "schemas", ORG_FLOW);
+    await mkdir(join(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(join(dir, "schema.yaml"), header + stringify(orgFlowSchema(), { lineWidth: 0 }), "utf8");
+    for (const a of ARTIFACTS) {
+        await writeFile(join(dir, "templates", `${a.id}.md`), a.template, "utf8");
+    }
+    return dir;
+}
+/** Set the default schema in openspec/config.yaml, keeping the rest of the file and its comments. */
+export async function setDefaultSchema(root, schema) {
+    const path = join(root, "openspec", "config.yaml");
+    let text = "";
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch {
+        // no config yet
+    }
+    const doc = parseDocument(text);
+    doc.set("schema", schema);
+    await writeFile(path, doc.toString({ lineWidth: 0 }), "utf8");
+}
+//# sourceMappingURL=org-flow.js.map

package/dist/org-flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-flow.js","sourceRoot":"","sources":["../src/org-flow.ts"],"names":[],"mappings":"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"}

package/dist/results.d.ts

@@ -0,0 +1,265 @@
+import { z } from "zod";
+/**
+ * Shapes of OpenSpec's `--json` output that Atticus relies on. Objects are loose: OpenSpec
+ * may add fields in a minor release, and that must not break Atticus. Fields listed here
+ * are the contract; the contract tests run them against the pinned OpenSpec version.
+ */
+export declare const OpenSpecRoot: z.ZodObject<{
+    path: z.ZodString;
+    source: z.ZodString;
+}, z.core.$loose>;
+export declare const StatusMessage: z.ZodObject<{
+    severity: z.ZodString;
+    code: z.ZodString;
+    message: z.ZodString;
+    fix: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** Error envelope OpenSpec prints with a non-zero exit. */
+export declare const ErrorEnvelope: z.ZodObject<{
+    status: z.ZodArray<z.ZodObject<{
+        severity: z.ZodString;
+        code: z.ZodString;
+        message: z.ZodString;
+        fix: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const NewChangeResult: z.ZodObject<{
+    change: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        schema: z.ZodString;
+    }, z.core.$loose>;
+    root: z.ZodObject<{
+        path: z.ZodString;
+        source: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ArtifactStatus: z.ZodObject<{
+    id: z.ZodString;
+    outputPath: z.ZodString;
+    status: z.ZodString;
+    requires: z.ZodArray<z.ZodString>;
+    missingDeps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const ChangeStatus: z.ZodObject<{
+    changeName: z.ZodString;
+    schemaName: z.ZodString;
+    isComplete: z.ZodBoolean;
+    applyRequires: z.ZodArray<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        outputPath: z.ZodString;
+        status: z.ZodString;
+        requires: z.ZodArray<z.ZodString>;
+        missingDeps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    root: z.ZodObject<{
+        path: z.ZodString;
+        source: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type ChangeStatus = z.infer<typeof ChangeStatus>;
+export declare const ArtifactInstructions: z.ZodObject<{
+    changeName: z.ZodString;
+    artifactId: z.ZodString;
+    schemaName: z.ZodString;
+    outputPath: z.ZodString;
+    description: z.ZodString;
+    instruction: z.ZodOptional<z.ZodString>;
+    template: z.ZodString;
+    dependencies: z.ZodArray<z.ZodUnknown>;
+    unlocks: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+export type ArtifactInstructions = z.infer<typeof ArtifactInstructions>;
+export declare const ApplyTask: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    done: z.ZodBoolean;
+    line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const ApplyInstructions: z.ZodObject<{
+    changeName: z.ZodString;
+    schemaName: z.ZodString;
+    progress: z.ZodObject<{
+        total: z.ZodNumber;
+        complete: z.ZodNumber;
+        remaining: z.ZodNumber;
+    }, z.core.$loose>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        done: z.ZodBoolean;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type ApplyInstructions = z.infer<typeof ApplyInstructions>;
+export declare const ValidationIssue: z.ZodObject<{
+    level: z.ZodEnum<{
+        ERROR: "ERROR";
+        WARNING: "WARNING";
+        INFO: "INFO";
+    }>;
+    path: z.ZodString;
+    message: z.ZodString;
+}, z.core.$loose>;
+export type ValidationIssue = z.infer<typeof ValidationIssue>;
+export declare const ValidationItem: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        change: "change";
+        spec: "spec";
+    }>;
+    valid: z.ZodBoolean;
+    issues: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            ERROR: "ERROR";
+            WARNING: "WARNING";
+            INFO: "INFO";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type ValidationItem = z.infer<typeof ValidationItem>;
+export declare const ValidationReport: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            change: "change";
+            spec: "spec";
+        }>;
+        valid: z.ZodBoolean;
+        issues: z.ZodArray<z.ZodObject<{
+            level: z.ZodEnum<{
+                ERROR: "ERROR";
+                WARNING: "WARNING";
+                INFO: "INFO";
+            }>;
+            path: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    summary: z.ZodObject<{
+        totals: z.ZodObject<{
+            items: z.ZodNumber;
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type ValidationReport = z.infer<typeof ValidationReport>;
+export declare const ChangeSummary: z.ZodObject<{
+    name: z.ZodString;
+    completedTasks: z.ZodNumber;
+    totalTasks: z.ZodNumber;
+    lastModified: z.ZodString;
+    status: z.ZodString;
+}, z.core.$loose>;
+export type ChangeSummary = z.infer<typeof ChangeSummary>;
+export declare const ChangeList: z.ZodObject<{
+    changes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        completedTasks: z.ZodNumber;
+        totalTasks: z.ZodNumber;
+        lastModified: z.ZodString;
+        status: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const SpecSummary: z.ZodObject<{
+    id: z.ZodString;
+    requirementCount: z.ZodNumber;
+}, z.core.$loose>;
+export type SpecSummary = z.infer<typeof SpecSummary>;
+export declare const SpecList: z.ZodObject<{
+    specs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        requirementCount: z.ZodNumber;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const Scenario: z.ZodObject<{
+    name: z.ZodString;
+    rawText: z.ZodString;
+}, z.core.$loose>;
+export declare const Requirement: z.ZodObject<{
+    name: z.ZodString;
+    text: z.ZodString;
+    scenarios: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        rawText: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type Requirement = z.infer<typeof Requirement>;
+export declare const Delta: z.ZodObject<{
+    spec: z.ZodString;
+    operation: z.ZodEnum<{
+        ADDED: "ADDED";
+        MODIFIED: "MODIFIED";
+        REMOVED: "REMOVED";
+        RENAMED: "RENAMED";
+    }>;
+    description: z.ZodString;
+    requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        text: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            rawText: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type Delta = z.infer<typeof Delta>;
+export declare const ChangeDetail: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    deltaCount: z.ZodNumber;
+    deltas: z.ZodArray<z.ZodObject<{
+        spec: z.ZodString;
+        operation: z.ZodEnum<{
+            ADDED: "ADDED";
+            MODIFIED: "MODIFIED";
+            REMOVED: "REMOVED";
+            RENAMED: "RENAMED";
+        }>;
+        description: z.ZodString;
+        requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            text: z.ZodString;
+            scenarios: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                rawText: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type ChangeDetail = z.infer<typeof ChangeDetail>;
+export declare const SpecDetail: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    overview: z.ZodString;
+    requirementCount: z.ZodNumber;
+    requirements: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        text: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            rawText: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type SpecDetail = z.infer<typeof SpecDetail>;
+export declare const ArchiveResult: z.ZodObject<{
+    archive: z.ZodObject<{
+        change: z.ZodString;
+        archivedAs: z.ZodString;
+        path: z.ZodString;
+        specsUpdated: z.ZodBoolean;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type ArchiveResult = z.infer<typeof ArchiveResult>;
+export declare const SchemaInfo: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodString>;
+    source: z.ZodString;
+}, z.core.$loose>;
+export type SchemaInfo = z.infer<typeof SchemaInfo>;

package/dist/results.js

@@ -0,0 +1,125 @@
+import { z } from "zod";
+/**
+ * Shapes of OpenSpec's `--json` output that Atticus relies on. Objects are loose: OpenSpec
+ * may add fields in a minor release, and that must not break Atticus. Fields listed here
+ * are the contract; the contract tests run them against the pinned OpenSpec version.
+ */
+export const OpenSpecRoot = z.looseObject({ path: z.string(), source: z.string() });
+export const StatusMessage = z.looseObject({
+    severity: z.string(),
+    code: z.string(),
+    message: z.string(),
+    fix: z.string().optional(),
+});
+/** Error envelope OpenSpec prints with a non-zero exit. */
+export const ErrorEnvelope = z.looseObject({ status: z.array(StatusMessage).min(1) });
+export const NewChangeResult = z.looseObject({
+    change: z.looseObject({ id: z.string(), path: z.string(), schema: z.string() }),
+    root: OpenSpecRoot,
+});
+export const ArtifactStatus = z.looseObject({
+    id: z.string(),
+    outputPath: z.string(),
+    /** done, ready (all requirements met) or blocked. */
+    status: z.string(),
+    requires: z.array(z.string()),
+    missingDeps: z.array(z.string()).optional(),
+});
+export const ChangeStatus = z.looseObject({
+    changeName: z.string(),
+    schemaName: z.string(),
+    isComplete: z.boolean(),
+    applyRequires: z.array(z.string()),
+    artifacts: z.array(ArtifactStatus),
+    root: OpenSpecRoot,
+});
+export const ArtifactInstructions = z.looseObject({
+    changeName: z.string(),
+    artifactId: z.string(),
+    schemaName: z.string(),
+    outputPath: z.string(),
+    description: z.string(),
+    instruction: z.string().optional(),
+    template: z.string(),
+    dependencies: z.array(z.unknown()),
+    unlocks: z.array(z.string()),
+});
+export const ApplyTask = z.looseObject({
+    id: z.string(),
+    description: z.string(),
+    done: z.boolean(),
+    line: z.number().optional(),
+});
+export const ApplyInstructions = z.looseObject({
+    changeName: z.string(),
+    schemaName: z.string(),
+    progress: z.looseObject({ total: z.number(), complete: z.number(), remaining: z.number() }),
+    tasks: z.array(ApplyTask),
+});
+export const ValidationIssue = z.looseObject({
+    level: z.enum(["ERROR", "WARNING", "INFO"]),
+    path: z.string(),
+    message: z.string(),
+});
+export const ValidationItem = z.looseObject({
+    id: z.string(),
+    type: z.enum(["change", "spec"]),
+    valid: z.boolean(),
+    issues: z.array(ValidationIssue),
+});
+export const ValidationReport = z.looseObject({
+    items: z.array(ValidationItem),
+    summary: z.looseObject({
+        totals: z.looseObject({ items: z.number(), passed: z.number(), failed: z.number() }),
+    }),
+});
+export const ChangeSummary = z.looseObject({
+    name: z.string(),
+    completedTasks: z.number(),
+    totalTasks: z.number(),
+    lastModified: z.string(),
+    status: z.string(),
+});
+export const ChangeList = z.looseObject({ changes: z.array(ChangeSummary) });
+export const SpecSummary = z.looseObject({ id: z.string(), requirementCount: z.number() });
+export const SpecList = z.looseObject({ specs: z.array(SpecSummary) });
+export const Scenario = z.looseObject({ name: z.string(), rawText: z.string() });
+export const Requirement = z.looseObject({
+    name: z.string(),
+    text: z.string(),
+    scenarios: z.array(Scenario),
+});
+export const Delta = z.looseObject({
+    spec: z.string(),
+    operation: z.enum(["ADDED", "MODIFIED", "REMOVED", "RENAMED"]),
+    description: z.string(),
+    requirements: z.array(Requirement).optional(),
+});
+export const ChangeDetail = z.looseObject({
+    id: z.string(),
+    title: z.string(),
+    deltaCount: z.number(),
+    deltas: z.array(Delta),
+});
+export const SpecDetail = z.looseObject({
+    id: z.string(),
+    title: z.string(),
+    overview: z.string(),
+    requirementCount: z.number(),
+    requirements: z.array(Requirement),
+});
+export const ArchiveResult = z.looseObject({
+    archive: z.looseObject({
+        change: z.string(),
+        archivedAs: z.string(),
+        path: z.string(),
+        specsUpdated: z.boolean(),
+    }),
+});
+export const SchemaInfo = z.looseObject({
+    name: z.string(),
+    description: z.string().optional(),
+    artifacts: z.array(z.string()),
+    source: z.string(),
+});
+//# sourceMappingURL=results.js.map