nikos 0.1.0 → 0.2.0

package/dist/commands/step.js

@@ -1,4 +1,4 @@
-import { writeFileSync } from "node:fs";
+import { store } from "../lib/store.js";
 import { join } from "node:path";
 import { isMap, isSeq, parseDocument } from "yaml";
 import { findIntentDir, read } from "../lib/project.js";
@@ -33,9 +33,45 @@ export function newStep(input, dir) {
         steps.add(map.createNode({ id, title }));
     else
         activity.set("steps", map.createNode([{ id, title }]));
-    writeFileSync(mapPath, map.toString(yamlOpts));
+    store().write(mapPath, map.toString(yamlOpts));
     return { id, validation: validate(intentDir) };
 }
+/** Add an activity to the story map, e.g. an area of an existing product or an imported epic. Returns its id; an existing one is left as it is. */
+export function newActivity(input, dir) {
+    const title = input.title?.trim();
+    if (!title)
+        throw new Error("An activity needs a title");
+    const intentDir = findIntentDir(dir);
+    const mapPath = join(intentDir, "storymap.yaml");
+    const map = parseDocument(read(mapPath));
+    const id = input.id ?? slugify(title);
+    const activities = map.get("activities", true);
+    if (!isSeq(activities))
+        throw new Error("storymap.yaml has no activities list");
+    if (activities.items.some((a) => isMap(a) && a.get("id") === id))
+        return id;
+    activities.add(map.createNode({ id, title }));
+    store().write(mapPath, map.toString(yamlOpts));
+    return id;
+}
+export function runActivity(args) {
+    const [sub, title, ...rest] = args;
+    const i = rest.indexOf("--id");
+    const d = rest.indexOf("--dir");
+    if (sub !== "add" || !title || title.startsWith("--")) {
+        console.error('Usage: nikos activity add "<title>" [--id <activity-id>]');
+        return 1;
+    }
+    try {
+        const id = newActivity({ title, id: i >= 0 ? rest[i + 1] : undefined }, d >= 0 ? rest[d + 1] : process.cwd());
+        console.log(`Activity ${id}: its stories go in intent/features/${id}/`);
+        return 0;
+    }
+    catch (err) {
+        console.error(`✗ ${err.message}`);
+        return 1;
+    }
+}
 export function runStep(args) {
     const [sub, title, ...rest] = args;
     const opt = (n) => {

package/dist/commands/story.d.ts

@@ -0,0 +1,21 @@
+import { type ValidationResult } from "./validate.js";
+declare const PRIORITIES: readonly ["must", "should", "could"];
+export interface StoryInput {
+    title: string;
+    activity: string;
+    /** A step of that activity. */
+    step?: string;
+    /** Release number; defaults to the last release. */
+    release?: number;
+    priority?: (typeof PRIORITIES)[number];
+}
+export interface StoryResult {
+    id: string;
+    release: number;
+    feature: string;
+    validation: ValidationResult;
+}
+/** Add a story to storymap.yaml and state.yaml, and write its starter feature file. */
+export declare function newStory(input: StoryInput, dir: string): StoryResult;
+export declare function runStory(args: string[]): number;
+export {};

package/dist/commands/story.js

@@ -1,7 +1,8 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { parseDocument, YAMLSeq } from "yaml";
 import { findIntentDir, read } from "../lib/project.js";
+import { store } from "../lib/store.js";
+import { createStoryState } from "../lib/state-files.js";
 import { slugify } from "./init.js";
 import { validate } from "./validate.js";
 const PRIORITIES = ["must", "should", "could"];
@@ -16,10 +17,8 @@ export function newStory(input, dir) {
         throw new Error(`'${priority}' is not a priority (must, should, could)`);
     const intentDir = findIntentDir(dir);
     const mapPath = join(intentDir, "storymap.yaml");
-    const statePath = join(intentDir, "state.yaml");
     // Documents keep comments and the order of everything we don't touch.
     const map = parseDocument(read(mapPath));
-    const state = parseDocument(read(statePath));
     const plain = map.toJS();
     const activities = (plain.activities ?? []).map((a) => a?.id);
     if (!activities.includes(input.activity)) {
@@ -42,14 +41,13 @@ export function newStory(input, dir) {
     const taken = releases.flatMap((r) => r?.stories ?? []).map((s) => Number(s.slice(key.length + 1)) || 0);
     const id = `${key}-${Math.max(0, ...taken) + 1}`;
     const feature = join(intentDir, "features", input.activity, `${slugify(title)}.feature`);
-    if (existsSync(feature))
+    if (store().exists(feature))
         throw new Error(`${feature} already exists; give the story a different title`);
     const stories = map.getIn(["releases", index, "stories"], true);
     if (stories instanceof YAMLSeq)
         stories.add(id);
     else
         map.setIn(["releases", index, "stories"], map.createNode([id], { flow: true }));
-    state.setIn(["stories", id], state.createNode({ status: "todo" }));
     const text = `@${id} @release-${release} @${priority} @activity-${input.activity}${input.step ? ` @step-${input.step}` : ""}
 Feature: ${title}
 
@@ -63,10 +61,9 @@ Feature: ${title}
     When <the one action>
     Then <what they see>
 `;
-    mkdirSync(dirname(feature), { recursive: true });
-    writeFileSync(feature, text, { flag: "wx" });
-    writeFileSync(mapPath, map.toString(yamlOpts));
-    writeFileSync(statePath, state.toString(yamlOpts));
+    store().write(feature, text, { create: true });
+    store().write(mapPath, map.toString(yamlOpts));
+    createStoryState(intentDir, id, { status: "todo" });
     return { id, release, feature, validation: validate(intentDir) };
 }
 export function runStory(args) {

package/dist/commands/suggest.d.ts

@@ -0,0 +1,16 @@
+export interface Option {
+    /** What the person sees, e.g. "Build HT-3: Reorder tasks". */
+    label: string;
+    /** What picking it means, for the agent: a playbook to run or a question to ask. */
+    do: string;
+    /** Stories it's about, when there are any. */
+    stories?: string[];
+}
+export interface Suggestion {
+    /** One line on where things stand, for the top of a reply or a session start. */
+    summary: string;
+    /** Two to four options, the most useful first. */
+    options: Option[];
+}
+export declare function suggest(dir: string): Suggestion;
+export declare function runSuggest(args: string[]): number;

package/dist/commands/suggest.js

@@ -0,0 +1,140 @@
+// `nikos suggest`: what the person could do next, as a short menu. nikOS works the options out
+// from the repo so every agent offers the same ones for the same situation; the agent asks the
+// question in its own way (a multiple-choice prompt where it has one) and runs what's picked.
+// Labels are plain words for the person. `do` tells the agent what a pick means; it's never
+// shown as a command for the person to run.
+import { store } from "../lib/store.js";
+import { resolveSettings } from "../lib/settings.js";
+import { dirname, join, resolve } from "node:path";
+import { findIntentDir, isDone } from "../lib/project.js";
+import { storyMapOf } from "./map.js";
+import { next } from "./next.js";
+import { validate } from "./validate.js";
+import { isStale } from "../planning/krs.js";
+import { betIds, krIds, loadBet, loadKr, today } from "../planning/model.js";
+const MAX = 4;
+const named = (s) => `${s.id}: ${s.title}`;
+const list = (ids) => (ids.length <= 3 ? ids.join(", ") : `${ids.slice(0, 2).join(", ")} and ${ids.length - 2} more`);
+export function suggest(dir) {
+    const intentDir = findIntentDir(dir);
+    if (!store().exists(join(intentDir, "storymap.yaml"))) {
+        return {
+            summary: "nikOS isn't set up in this repo yet.",
+            options: [
+                { label: "Set up nikOS here", do: "Run the start playbook: nikos start, then the first story through to passing." },
+                { label: "Map what this repo already does", do: "Run the map-existing playbook: draft the story map from the existing code, then prove what's there with scenarios." },
+                { label: "Join our company plan", do: "Ask which repo holds the company or department plan, then nikos join <repo path> (add --host for GitLab). It links this repo and shows the settings it inherits." },
+            ],
+        };
+    }
+    const map = storyMapOf(dir);
+    const stories = [...map.releases.flatMap((r) => r.stories), ...map.unreleased];
+    const byId = new Map(stories.map((s) => [s.id, s]));
+    const options = [];
+    const add = (o) => options.length < MAX && options.push(o);
+    const problems = validate(dir).errors.length;
+    if (problems)
+        add({ label: `Fix the ${problems} ${problems === 1 ? "problem" : "problems"} in intent/`, do: "Run nikos validate and fix each error it lists." });
+    const changed = stories.filter((s) => s.specChanged);
+    if (changed.length)
+        add({ label: `Review what changed in ${list(changed.map((s) => s.id))} since it was done`, do: "Show the feature's change since done, and ask whether to move it back to needs_rework.", stories: changed.map((s) => s.id) });
+    const n = next(intentDir);
+    for (const o of n.open) {
+        const s = byId.get(o.id);
+        add({ label: `${o.status === "needs_rework" ? "Rework" : "Finish"} ${s ? named(s) : o.id}`, do: "Run the build-a-story playbook for this story.", stories: [o.id] });
+    }
+    // Done stories nobody has signed off (the map shows a story with an approval that holds as
+    // approved): the agent asks "Do you want to approve …?"
+    const approvalsOn = resolveSettings(dirname(intentDir))["approval.policy"].value !== "off";
+    const unapproved = approvalsOn ? stories.filter((s) => s.status === "done" && !s.specChanged) : [];
+    if (unapproved.length) {
+        add({
+            label: unapproved.length === 1 ? `Approve ${named(unapproved[0])}` : `Approve ${unapproved.length} done stories (${list(unapproved.map((s) => s.id))})`,
+            do: "Ask the person, for each story, \"Do you want to approve <id>: <title>?\" with Approve, Not yet and Show me what was checked. Only on their Approve, run nikos approve <id> --via chat.",
+            stories: unapproved.map((s) => s.id),
+        });
+    }
+    if (n.story) {
+        const s = byId.get(n.story);
+        add({ label: `Build ${s ? named(s) : n.story}`, do: "Run the build-a-story playbook for this story.", stories: [n.story] });
+    }
+    else if (n.waiting.length) {
+        const blocker = n.waiting[0].on[0];
+        add({ label: `Unblock ${blocker} (${n.waiting[0].id} waits on it)`, do: `Run the build-a-story playbook for ${blocker}, or ask whether to change the order.`, stories: [blocker] });
+    }
+    // The latest release whose stories are all done: time to check it's ready to ship.
+    const complete = (r) => {
+        const live = r.stories.filter((s) => s.status !== "cancelled");
+        return live.length > 0 && live.every((s) => isDone(s.status) && !s.specChanged);
+    };
+    const ready = map.releases.filter(complete).at(-1);
+    if (ready)
+        add({ label: `Check release ${ready.number} is ready to ship`, do: `Run nikos release check ${ready.number} --run and report what it finds.` });
+    // The planning rituals, where the repo plans with nikOS: bets due for review, then stale key results.
+    const root = dirname(intentDir);
+    if (store().isDir(join(root, "planning"))) {
+        const due = betIds(root).flatMap((id) => {
+            try {
+                const m = loadBet(root, id).meta;
+                return m.outcome === "open" && m.review_on && String(m.review_on) <= today() ? [{ id, on: String(m.review_on) }] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+        if (due.length)
+            add({ label: due.length === 1 ? `Review the ${due[0].id} bet (due ${due[0].on})` : `Review ${due.length} bets that are due`, do: "Run the nikos-planning review playbook: continue, change, stop or complete each bet, with the reason." });
+        const stale = krIds(root).flatMap((id) => {
+            try {
+                const k = loadKr(root, id).data;
+                return isStale(k) ? [String(k.title ?? id)] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+        if (stale.length)
+            add({ label: stale.length === 1 ? `Check in on "${stale[0]}"` : `Check in on ${stale.length} key results`, do: "Run the nikos-planning checkin playbook: ask for each key result's latest value and record it." });
+    }
+    add({ label: "Add a story", do: "Ask what the person wants the product to do next, then add it with nikos story add and write its scenarios." });
+    add({ label: "Look at the story map", do: "Run nikos map, or open the planning dashboard's map if it's running, and show the person." });
+    // The release being worked on: the first that isn't complete, or the last.
+    const current = map.releases.find((r) => !complete(r)) ?? map.releases.at(-1);
+    const live = current ? current.stories.filter((s) => s.status !== "cancelled") : [];
+    const doing = stories.filter((s) => s.status === "in_progress").map((s) => s.id);
+    const summary = current
+        ? `Release ${current.number} · ${current.title}: ${live.filter((s) => isDone(s.status)).length} of ${live.length} done${doing.length ? ` · ${list(doing)} in progress` : ""}${unapproved.length ? ` · ${unapproved.length} waiting for approval` : ""}${problems ? ` · ${problems} ${problems === 1 ? "problem" : "problems"} in intent/` : ""}`
+        : "The story map has no releases yet.";
+    return { summary, options };
+}
+export function runSuggest(args) {
+    const i = args.indexOf("--dir");
+    const dir = resolve(i >= 0 ? args[i + 1] : process.cwd());
+    // --brief is for a session-start hook: one line, and nothing at all outside a nikOS repo.
+    if (args.includes("--brief")) {
+        if (!store().exists(join(findIntentDir(dir), "storymap.yaml")))
+            return 0;
+        try {
+            const s = suggest(dir);
+            console.log(`nikOS: ${s.summary}. Suggested next: ${s.options.map((o) => o.label).join(" · ")}.`);
+        }
+        catch {
+            // A hook must never break the session.
+        }
+        return 0;
+    }
+    try {
+        const s = suggest(dir);
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(s, null, 2));
+            return 0;
+        }
+        console.log(s.summary);
+        s.options.forEach((o, n) => console.log(`  ${n + 1}. ${o.label}`));
+        return 0;
+    }
+    catch (err) {
+        console.error(`✗ ${err.message}`);
+        return 1;
+    }
+}

package/dist/commands/tracker.d.ts

@@ -0,0 +1,60 @@
+export type NikosStatus = "todo" | "in_progress" | "needs_rework" | "done" | "approved" | "cancelled";
+/** Link a story to its ticket (e.g. PAY-123, ENG-42, #57), in state.yaml. */
+export declare function linkTicket(input: {
+    id: string;
+    ticket: string;
+}, dir: string): {
+    id: string;
+    ticket: string;
+};
+export interface RecordResult {
+    id: string;
+    ticket?: string;
+    /** What the tracker's status means to nikOS. */
+    means: NikosStatus;
+    /** What nikOS did about it. */
+    outcome: "approved" | "cancelled" | "in step" | "differs" | "ignored";
+    message: string;
+}
+/**
+ * Record what a story's ticket says, as the agent read it from the tracker. Approved (when
+ * tracker.approvals is on) approves the story; cancelled cancels it; anything else is only
+ * compared, because nikOS's own status comes from the story's scenarios.
+ */
+export declare function recordTicket(input: {
+    id: string;
+    status: string;
+    by?: string;
+    on?: string;
+}, dir: string): RecordResult;
+export interface TicketMove {
+    id: string;
+    ticket: string;
+    nikos: NikosStatus;
+    /** The tracker status the ticket should have: the first one mapped to the story's status. */
+    status: string;
+}
+/** For each linked story, the tracker status its ticket should be in. The agent moves the tickets. */
+export declare function ticketMoves(dir: string): TicketMove[];
+export interface ImportedTicket {
+    /** The ticket's key or number, e.g. PAY-123. */
+    key: string;
+    title: string;
+    /** The epic, project or label it belongs to: it becomes the story's activity. */
+    group?: string;
+}
+/**
+ * Bring a tracker's backlog into the story map: each ticket becomes a story (in the last
+ * release, or release), linked to its ticket, with its group as the activity. Tickets already
+ * linked are skipped. Stories start as todo: their scenarios still have to be written.
+ */
+export declare function importTickets(tickets: ImportedTicket[], dir: string, opts?: {
+    release?: number;
+}): {
+    added: {
+        id: string;
+        ticket: string;
+    }[];
+    skipped: string[];
+};
+export declare function runTracker(args: string[]): number;

package/dist/commands/tracker.js

@@ -0,0 +1,185 @@
+// `nikos tracker`: keep a story map and a team's tracker (Jira, Linear, GitHub or GitLab issues…)
+// in step. nikOS never calls a tracker itself: the agent reads and writes tickets through the
+// tracker's own MCP, and hands what it read to these commands, which apply the rules:
+// - a ticket can approve a story (when tracker.approvals is on) or cancel it, never mark it
+//   done: done still means the story's scenarios pass;
+// - for everything else, nikOS says which tickets should move, and the agent moves them.
+import { dirname } from "node:path";
+import { findIntentDir, STORY_ID } from "../lib/project.js";
+import { resolveSettings } from "../lib/settings.js";
+import { store } from "../lib/store.js";
+import { noEntry, storyState, updateStory } from "../lib/state-files.js";
+import { approve } from "./approve.js";
+import { storyMapOf } from "./map.js";
+import { setState, StateError } from "./state.js";
+import { newStory } from "./story.js";
+import { newActivity } from "./step.js";
+/** The tracker settings that apply here. */
+function trackerOf(root) {
+    const s = resolveSettings(root);
+    return {
+        system: s["tracker.system"].value,
+        statuses: s["tracker.statuses"].value,
+        approvals: s["tracker.approvals"].value,
+    };
+}
+const rootOf = (dir) => dirname(findIntentDir(dir));
+/** Link a story to its ticket (e.g. PAY-123, ENG-42, #57), in state.yaml. */
+export function linkTicket(input, dir) {
+    if (!STORY_ID.test(input.id))
+        throw new Error(`'${input.id}' is not a story id (expected e.g. HT-1)`);
+    const ticket = input.ticket.trim();
+    if (!ticket)
+        throw new Error("Give the ticket's key or number, e.g. PAY-123");
+    const intent = findIntentDir(dir);
+    if (!storyState(intent, input.id))
+        throw new Error(noEntry(intent, input.id));
+    updateStory(intent, input.id, (doc, at) => doc.setIn([...at, "ticket"], ticket));
+    return { id: input.id, ticket };
+}
+/**
+ * Record what a story's ticket says, as the agent read it from the tracker. Approved (when
+ * tracker.approvals is on) approves the story; cancelled cancels it; anything else is only
+ * compared, because nikOS's own status comes from the story's scenarios.
+ */
+export function recordTicket(input, dir) {
+    const root = rootOf(dir);
+    const t = trackerOf(root);
+    if (t.system === "none")
+        throw new Error("No tracker is set up here: set tracker.system first (nikos settings set tracker.system jira)");
+    const means = t.statuses[input.status];
+    if (!means) {
+        throw new Error(`'${input.status}' isn't mapped to a nikOS status. Mapped: ${Object.keys(t.statuses).join(", ") || "none"}. Map it first: nikos settings set tracker.statuses '{"${input.status}": "done"}'`);
+    }
+    const story = storyMapOf(root).releases.flatMap((r) => r.stories).find((s) => s.id === input.id);
+    if (!story)
+        throw new Error(`${input.id} is not in any release in storymap.yaml`);
+    const ticket = storyTicket(root, input.id);
+    const base = { id: input.id, ...(ticket ? { ticket } : {}), means };
+    if (means === "approved") {
+        if (!t.approvals)
+            return { ...base, outcome: "ignored", message: `${t.system} says approved, but tracker approvals don't count here (tracker.approvals is off)` };
+        if (story.status === "approved")
+            return { ...base, outcome: "in step", message: `${input.id} is already approved` };
+        if (!input.by)
+            throw new Error(`Say who moved the ticket to '${input.status}' (--by), as the tracker's history shows it`);
+        approve(input.id, { dir, by: input.by, date: input.on, via: "tracker" });
+        return { ...base, outcome: "approved", message: `${input.id} approved by ${input.by} in ${t.system}${ticket ? ` (${ticket})` : ""}` };
+    }
+    if (means === "cancelled") {
+        if (story.status === "cancelled")
+            return { ...base, outcome: "in step", message: `${input.id} is already cancelled` };
+        setState(input.id, "cancelled", { dir, reason: `Cancelled in ${t.system}${ticket ? ` (${ticket})` : ""}${input.by ? ` by ${input.by}` : ""}`, date: input.on });
+        return { ...base, outcome: "cancelled", message: `${input.id} cancelled, as ${t.system} says` };
+    }
+    const nikos = story.status === "approved" ? "done" : story.status;
+    if (nikos === means)
+        return { ...base, outcome: "in step", message: `${input.id} is ${means} in both` };
+    return {
+        ...base,
+        outcome: "differs",
+        message: `${t.system} says ${means} but nikOS says ${nikos}. nikOS's status comes from the story's scenarios, so move the ticket to match (nikos tracker sync lists the status to move it to)`,
+    };
+}
+function storyTicket(root, id) {
+    const v = storyState(findIntentDir(root), id)?.ticket;
+    return typeof v === "string" ? v : undefined;
+}
+/** For each linked story, the tracker status its ticket should be in. The agent moves the tickets. */
+export function ticketMoves(dir) {
+    const root = rootOf(dir);
+    const t = trackerOf(root);
+    const stories = storyMapOf(root).releases.flatMap((r) => r.stories);
+    const statusFor = (s) => Object.entries(t.statuses).find(([, v]) => v === s)?.[0] ?? (s === "approved" ? Object.entries(t.statuses).find(([, v]) => v === "done")?.[0] : undefined);
+    const out = [];
+    for (const s of stories) {
+        const ticket = storyTicket(root, s.id);
+        const status = statusFor(s.status);
+        if (ticket && status)
+            out.push({ id: s.id, ticket, nikos: s.status, status });
+    }
+    return out;
+}
+/**
+ * Bring a tracker's backlog into the story map: each ticket becomes a story (in the last
+ * release, or release), linked to its ticket, with its group as the activity. Tickets already
+ * linked are skipped. Stories start as todo: their scenarios still have to be written.
+ */
+export function importTickets(tickets, dir, opts = {}) {
+    const root = rootOf(dir);
+    const linked = new Set(storyMapOf(root).releases.flatMap((r) => r.stories).map((s) => storyTicket(root, s.id)).filter(Boolean));
+    const added = [];
+    const skipped = [];
+    for (const t of tickets) {
+        if (!t?.key || !t?.title)
+            throw new Error("Each ticket needs a key and a title");
+        if (linked.has(t.key)) {
+            skipped.push(t.key);
+            continue;
+        }
+        const activity = newActivity({ title: t.group?.trim() || "Backlog" }, dir);
+        let story;
+        try {
+            story = newStory({ title: t.title, activity, release: opts.release }, dir);
+        }
+        catch (err) {
+            // Two tickets with the same title in one group: tell them apart by key.
+            if (!/already exists/.test(err.message))
+                throw err;
+            story = newStory({ title: `${t.title} (${t.key})`, activity, release: opts.release }, dir);
+        }
+        linkTicket({ id: story.id, ticket: t.key }, dir);
+        linked.add(t.key);
+        added.push({ id: story.id, ticket: t.key });
+    }
+    return { added, skipped };
+}
+const USAGE = `Usage:
+  nikos tracker link <story-id> <ticket>
+  nikos tracker record <story-id> --status "<tracker status>" [--by "<who moved it>"] [--on <date>]
+  nikos tracker sync [--json]          which tickets should move, and to what
+  nikos tracker import <tickets.json> [--release <n>]   [{ "key", "title", "group" }]`;
+export function runTracker(args) {
+    const [sub, ...rest] = args;
+    const flag = (n) => {
+        const i = rest.indexOf(`--${n}`);
+        return i >= 0 ? rest[i + 1] : undefined;
+    };
+    const positional = rest.filter((a, i) => !a.startsWith("--") && !(i > 0 && rest[i - 1].startsWith("--")));
+    const dir = flag("dir") ?? process.cwd();
+    try {
+        if (sub === "link" && positional[1]) {
+            const r = linkTicket({ id: positional[0], ticket: positional[1] }, dir);
+            console.log(`${r.id} ↔ ${r.ticket}`);
+        }
+        else if (sub === "record" && positional[0] && flag("status")) {
+            const r = recordTicket({ id: positional[0], status: flag("status"), by: flag("by"), on: flag("on") }, dir);
+            console.log(`${r.outcome === "differs" ? "!" : "✓"} ${r.message}`);
+        }
+        else if (sub === "sync") {
+            const moves = ticketMoves(dir);
+            if (rest.includes("--json"))
+                console.log(JSON.stringify(moves, null, 2));
+            else
+                for (const m of moves)
+                    console.log(`${m.ticket} → ${m.status}  (${m.id} is ${m.nikos})`);
+        }
+        else if (sub === "import" && positional[0]) {
+            const tickets = JSON.parse(store().read(positional[0]));
+            const r = importTickets(tickets, dir, { release: flag("release") ? Number(flag("release")) : undefined });
+            for (const a of r.added)
+                console.log(`+ ${a.id} ↔ ${a.ticket}`);
+            if (r.skipped.length)
+                console.log(`Already linked: ${r.skipped.join(", ")}`);
+        }
+        else {
+            console.error(USAGE);
+            return 1;
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`✗ ${err instanceof StateError ? err.message : err.message}`);
+        return 1;
+    }
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,15 @@
+export interface Issue {
+    file: string;
+    message: string;
+    hint?: string;
+}
+export interface ValidationResult {
+    dir: string;
+    errors: Issue[];
+    warnings: Issue[];
+    stories: number;
+    releases: number;
+}
+export declare function validate(start: string): ValidationResult;
+export declare function formatResult(r: ValidationResult): string;
+export declare function runValidate(args: string[]): number;