aglit 0.1.0

package/dist/index.js

@@ -0,0 +1,1206 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/index.ts
+import { run } from "@stricli/core";
+
+// src/app.ts
+import { buildApplication } from "@stricli/core";
+
+// src/routes.ts
+import { buildRouteMap } from "@stricli/core";
+
+// src/commands/init.ts
+import { buildCommand } from "@stricli/core";
+
+// ../sdk/dist/index.js
+import * as fs from "fs/promises";
+import * as path2 from "path";
+import * as path from "path";
+import * as path3 from "path";
+import { randomBytes } from "crypto";
+import * as fs2 from "fs/promises";
+import * as path4 from "path";
+var AGLIT_DIRNAME = ".aglit";
+var ISSUES_DIRNAME = "issues";
+var PROJECTS_DIRNAME = "projects";
+var CONFIG_FILENAME = "config.json";
+var LOCK_FILENAME = ".lock";
+var CONFIG_SCHEMA = "aglit.config.v1";
+var ISSUE_SCHEMA = "aglit.issue.md.v1";
+var PROJECT_SCHEMA = "aglit.project.md.v1";
+var ISSUE_STATUSES = [
+  "inbox",
+  "planned",
+  "active",
+  "blocked",
+  "done",
+  "canceled"
+];
+var PRIORITY_LEVELS = ["none", "low", "medium", "high"];
+function resolveRoot(rootDir) {
+  return rootDir ?? process.cwd();
+}
+function aglitDir(rootDir) {
+  return path.join(resolveRoot(rootDir), AGLIT_DIRNAME);
+}
+function issuesDir(rootDir) {
+  return path.join(aglitDir(rootDir), ISSUES_DIRNAME);
+}
+function projectsDir(rootDir) {
+  return path.join(aglitDir(rootDir), PROJECTS_DIRNAME);
+}
+function configPath(rootDir) {
+  return path.join(aglitDir(rootDir), CONFIG_FILENAME);
+}
+function lockPath(rootDir) {
+  return path.join(aglitDir(rootDir), LOCK_FILENAME);
+}
+function issuePath(rootDir, key) {
+  return path.join(issuesDir(rootDir), `${key}.md`);
+}
+function projectPath(rootDir, slug) {
+  return path.join(projectsDir(rootDir), `${slug}.md`);
+}
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function ensureLayout(rootDir) {
+  await ensureDir(aglitDir(rootDir));
+  await ensureDir(issuesDir(rootDir));
+  await ensureDir(projectsDir(rootDir));
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function readJsonFile(filePath) {
+  const raw = await fs.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+async function atomicWriteJson(filePath, data) {
+  const dir = path2.dirname(filePath);
+  const base = path2.basename(filePath);
+  const tmpPath = path2.join(dir, `.${base}.tmp`);
+  const json = `${JSON.stringify(data, null, 2)}
+`;
+  await fs.writeFile(tmpPath, json, "utf8");
+  await fs.rename(tmpPath, filePath);
+}
+async function atomicWriteText(filePath, text) {
+  const dir = path2.dirname(filePath);
+  const base = path2.basename(filePath);
+  const tmpPath = path2.join(dir, `.${base}.tmp`);
+  await fs.writeFile(tmpPath, text, "utf8");
+  await fs.rename(tmpPath, filePath);
+}
+async function readTextFile(filePath) {
+  return fs.readFile(filePath, "utf8");
+}
+async function listIssueFiles(rootDir) {
+  const dir = issuesDir(rootDir);
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => path2.join(dir, entry.name));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function listProjectFiles(rootDir) {
+  const dir = projectsDir(rootDir);
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => path2.join(dir, entry.name));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function ensureAglit(rootDir) {
+  await ensureLayout(rootDir);
+}
+function normalizePrefix(value) {
+  const normalized = value.trim().toUpperCase();
+  if (!/^[A-Z][A-Z0-9]*$/.test(normalized)) {
+    throw new Error("issuePrefix must start with a letter and contain only A-Z and 0-9");
+  }
+  return normalized;
+}
+async function getConfig(rootDir) {
+  const path32 = configPath(rootDir);
+  if (!await fileExists(path32)) {
+    return null;
+  }
+  const json = await readJsonFile(path32);
+  if (!json || typeof json !== "object" || Array.isArray(json)) {
+    throw new Error(`Invalid AGLIT config at ${path32}`);
+  }
+  const issuePrefix = json.issuePrefix;
+  if (typeof issuePrefix !== "string") {
+    throw new Error(`Invalid AGLIT config at ${path32}`);
+  }
+  return {
+    issuePrefix: normalizePrefix(issuePrefix),
+    schema: typeof json.schema === "string" ? json.schema : undefined
+  };
+}
+async function setConfig(rootDir, config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Invalid AGLIT config payload");
+  }
+  const issuePrefix = normalizePrefix(config.issuePrefix);
+  await ensureLayout(rootDir);
+  await atomicWriteJson(configPath(rootDir), {
+    schema: CONFIG_SCHEMA,
+    issuePrefix
+  });
+}
+async function resolveIssuePrefix(rootDir, inputPrefix) {
+  const existing = await getConfig(rootDir);
+  if (existing?.issuePrefix) {
+    return existing.issuePrefix;
+  }
+  if (!inputPrefix) {
+    throw new Error("Issue prefix not set. Run `aglit init --prefix ABC` or `aglit new --prefix ABC`.");
+  }
+  const prefix = normalizePrefix(inputPrefix);
+  const config = {
+    issuePrefix: prefix
+  };
+  await setConfig(rootDir, config);
+  return prefix;
+}
+function formatUuid(bytes) {
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+  return [
+    hex.slice(0, 4).join(""),
+    hex.slice(4, 6).join(""),
+    hex.slice(6, 8).join(""),
+    hex.slice(8, 10).join(""),
+    hex.slice(10, 16).join("")
+  ].join("-");
+}
+function generateId() {
+  const bun = globalThis.Bun;
+  if (bun?.randomUUIDv7) {
+    return bun.randomUUIDv7();
+  }
+  const bytes = randomBytes(16);
+  const now = BigInt(Date.now());
+  bytes[0] = Number(now >> 40n & 0xffn);
+  bytes[1] = Number(now >> 32n & 0xffn);
+  bytes[2] = Number(now >> 24n & 0xffn);
+  bytes[3] = Number(now >> 16n & 0xffn);
+  bytes[4] = Number(now >> 8n & 0xffn);
+  bytes[5] = Number(now & 0xffn);
+  bytes[6] = (bytes[6] ?? 0) & 15 | 112;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  return formatUuid(bytes);
+}
+function getBun() {
+  return globalThis.Bun ?? {};
+}
+function parseYaml(input) {
+  const bun = getBun();
+  if (!bun.YAML?.parse) {
+    throw new Error("Bun.YAML.parse unavailable");
+  }
+  return bun.YAML.parse(input);
+}
+function tryRenderMarkdown(input, callbacks) {
+  const bun = getBun();
+  if (!bun.markdown?.render) {
+    return false;
+  }
+  bun.markdown.render(input, callbacks);
+  return true;
+}
+function parseFrontmatter(text) {
+  const input = text.startsWith("\uFEFF") ? text.slice(1) : text;
+  if (!input.startsWith("---")) {
+    return { data: {}, body: text, hasFrontmatter: false };
+  }
+  const lines = input.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    return { data: {}, body: text, hasFrontmatter: false };
+  }
+  let endIndex = -1;
+  for (let i = 1;i < lines.length; i += 1) {
+    if (lines[i]?.trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return { data: {}, body: text, hasFrontmatter: false };
+  }
+  const raw = lines.slice(1, endIndex).join(`
+`);
+  let data = {};
+  let error;
+  if (raw.trim()) {
+    try {
+      const parsed = parseYaml(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        data = parsed;
+      }
+    } catch (caught) {
+      error = caught instanceof Error ? caught : new Error(String(caught));
+    }
+  }
+  const body = lines.slice(endIndex + 1).join(`
+`);
+  return { data, body, hasFrontmatter: true, error };
+}
+function getString(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : undefined;
+}
+function renderFrontmatter(data, order = []) {
+  const lines = ["---"];
+  const seen = new Set;
+  for (const key of order) {
+    const value = data[key];
+    if (value !== undefined) {
+      lines.push(`${key}: ${value}`);
+      seen.add(key);
+    }
+  }
+  for (const key of Object.keys(data)) {
+    if (seen.has(key)) {
+      continue;
+    }
+    const value = data[key];
+    if (value !== undefined) {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("---");
+  return lines.join(`
+`);
+}
+var DEFAULT_LOCK_TTL_MS = 30000;
+async function acquireLock(rootDir, options) {
+  const ttlMs = options?.ttlMs ?? DEFAULT_LOCK_TTL_MS;
+  const path32 = lockPath(rootDir);
+  await ensureLayout(rootDir);
+  try {
+    const handle = await fs2.open(path32, "wx");
+    try {
+      const payload = {
+        pid: process.pid,
+        createdAt: new Date().toISOString(),
+        expiresAt: new Date(Date.now() + ttlMs).toISOString()
+      };
+      await handle.writeFile(`${JSON.stringify(payload)}
+`, "utf8");
+    } finally {
+      await handle.close();
+    }
+    return;
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  const stat2 = await fs2.stat(path32);
+  const isStale = Date.now() - stat2.mtimeMs > ttlMs;
+  if (isStale) {
+    await fs2.unlink(path32);
+    return acquireLock(rootDir, options);
+  }
+  throw new Error(`AGLIT lock already held at ${path32}`);
+}
+async function releaseLock(rootDir) {
+  try {
+    await fs2.unlink(lockPath(rootDir));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+async function withLock(rootDir, fn, options) {
+  await acquireLock(rootDir, options);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(rootDir);
+  }
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function allocateIssueKey(rootDir, prefix) {
+  const files = await listIssueFiles(rootDir);
+  const pattern = new RegExp(`^${escapeRegExp(prefix)}-(\\d+)$`);
+  let max = 0;
+  for (const filePath of files) {
+    const key = path3.basename(filePath, ".md");
+    const match = key.match(pattern);
+    if (!match)
+      continue;
+    const value = Number(match[1]);
+    if (Number.isFinite(value) && value > max) {
+      max = value;
+    }
+  }
+  return `${prefix}-${max + 1}`;
+}
+function normalizeSlug(value) {
+  const trimmed = value.trim().toLowerCase();
+  const slug = trimmed.replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  return slug || "project";
+}
+async function allocateProjectSlug(rootDir, title, inputSlug) {
+  const base = normalizeSlug(inputSlug ?? title);
+  const files = await listProjectFiles(rootDir);
+  const existing = new Set(files.map((file) => path3.basename(file, ".md").toLowerCase()));
+  if (!existing.has(base)) {
+    return base;
+  }
+  let counter = 2;
+  while (existing.has(`${base}-${counter}`)) {
+    counter += 1;
+  }
+  return `${base}-${counter}`;
+}
+function issueTemplate(input) {
+  const frontmatter = renderFrontmatter({
+    schema: ISSUE_SCHEMA,
+    id: input.id,
+    status: input.status,
+    priority: input.priority,
+    ...input.projectId ? { projectId: input.projectId } : {}
+  }, ["schema", "id", "status", "priority", "projectId"]);
+  return [
+    frontmatter,
+    "",
+    `# ${input.title.trim()}`,
+    "",
+    "## Description",
+    "",
+    "## Acceptance",
+    "",
+    "## Constraints",
+    "",
+    "## Plan",
+    "",
+    "## Verification",
+    ""
+  ].join(`
+`);
+}
+function projectTemplate(input) {
+  const frontmatter = renderFrontmatter({
+    schema: PROJECT_SCHEMA,
+    id: input.id,
+    status: input.status,
+    priority: input.priority
+  }, ["schema", "id", "status", "priority"]);
+  return [
+    frontmatter,
+    "",
+    `# ${input.title.trim()}`,
+    "",
+    "## Description",
+    "",
+    "## Scope",
+    "",
+    "## Milestones",
+    "",
+    "## Notes",
+    ""
+  ].join(`
+`);
+}
+async function createIssueFile(rootDir, input) {
+  if (!input.title?.trim()) {
+    throw new Error("Issue title is required");
+  }
+  return withLock(rootDir, async () => {
+    await ensureLayout(rootDir);
+    const prefix = await resolveIssuePrefix(rootDir, input.prefix);
+    const key = await allocateIssueKey(rootDir, prefix);
+    const id = generateId();
+    const status = input.status ?? "inbox";
+    const priority = input.priority ?? "none";
+    const projectId = input.projectId?.trim() || undefined;
+    const content = issueTemplate({
+      title: input.title,
+      id,
+      status,
+      priority,
+      projectId
+    });
+    const filePath = issuePath(rootDir, key);
+    await atomicWriteText(filePath, content);
+    return { key, path: filePath, id };
+  });
+}
+async function createProjectFile(rootDir, input) {
+  if (!input.title?.trim()) {
+    throw new Error("Project title is required");
+  }
+  return withLock(rootDir, async () => {
+    await ensureLayout(rootDir);
+    const slug = await allocateProjectSlug(rootDir, input.title, input.slug);
+    const id = generateId();
+    const status = input.status ?? "inbox";
+    const priority = input.priority ?? "none";
+    const content = projectTemplate({
+      title: input.title,
+      id,
+      status,
+      priority
+    });
+    const filePath = projectPath(rootDir, slug);
+    await atomicWriteText(filePath, content);
+    return { slug, path: filePath, id };
+  });
+}
+function normalizeStatus(value) {
+  if (value && ISSUE_STATUSES.includes(value)) {
+    return value;
+  }
+  return "inbox";
+}
+function normalizePriority(value) {
+  if (value && PRIORITY_LEVELS.includes(value)) {
+    return value;
+  }
+  return "none";
+}
+function extractTitle(body) {
+  let title = null;
+  const usedMarkdown = tryRenderMarkdown(body, {
+    heading: (children, info) => {
+      if (!title && info.level === 1) {
+        const text = String(children).trim();
+        if (text) {
+          title = text;
+        }
+      }
+      return "";
+    }
+  });
+  if (!usedMarkdown) {
+    const match = body.match(/^#\s+(.+)$/m);
+    if (match?.[1]) {
+      return match[1].trim();
+    }
+  }
+  return title;
+}
+function parseIssueHeader(filePath, text) {
+  const key = path4.basename(filePath, ".md");
+  const { data, body } = parseFrontmatter(text);
+  const schema = getString(data, "schema");
+  const status = normalizeStatus(getString(data, "status"));
+  const priority = normalizePriority(getString(data, "priority"));
+  const title = extractTitle(body) ?? key;
+  return {
+    key,
+    id: getString(data, "id"),
+    status,
+    priority,
+    projectId: getString(data, "projectId"),
+    title,
+    path: filePath,
+    schema
+  };
+}
+function parseProjectHeader(filePath, text) {
+  const slug = path4.basename(filePath, ".md");
+  const { data, body } = parseFrontmatter(text);
+  const schema = getString(data, "schema");
+  const status = normalizeStatus(getString(data, "status"));
+  const priority = normalizePriority(getString(data, "priority"));
+  const title = extractTitle(body) ?? slug;
+  return {
+    slug,
+    id: getString(data, "id"),
+    status,
+    priority,
+    title,
+    path: filePath,
+    schema
+  };
+}
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2,
+  none: 3
+};
+function keyNumber(key) {
+  const match = key.match(/-(\d+)$/);
+  if (!match)
+    return null;
+  const value = Number(match[1]);
+  return Number.isFinite(value) ? value : null;
+}
+function compareIssue(a, b) {
+  if (a.priority !== b.priority) {
+    return PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
+  }
+  const aNum = keyNumber(a.key);
+  const bNum = keyNumber(b.key);
+  if (aNum !== null && bNum !== null && aNum !== bNum) {
+    return aNum - bNum;
+  }
+  return a.key.localeCompare(b.key);
+}
+function compareProject(a, b) {
+  if (a.priority !== b.priority) {
+    return PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
+  }
+  return a.slug.localeCompare(b.slug);
+}
+async function listIssueHeaders(rootDir, filter = {}) {
+  const files = await listIssueFiles(rootDir);
+  const headers = [];
+  const projectId = filter.projectId?.trim();
+  for (const filePath of files) {
+    const text = await readTextFile(filePath);
+    const header = parseIssueHeader(filePath, text);
+    if (filter.status && header.status !== filter.status) {
+      continue;
+    }
+    if (projectId && header.projectId !== projectId) {
+      continue;
+    }
+    headers.push(header);
+  }
+  headers.sort(compareIssue);
+  if (filter.limit && headers.length > filter.limit) {
+    return headers.slice(0, filter.limit);
+  }
+  return headers;
+}
+async function listProjectHeaders(rootDir, filter = {}) {
+  const files = await listProjectFiles(rootDir);
+  const headers = [];
+  for (const filePath of files) {
+    const text = await readTextFile(filePath);
+    const header = parseProjectHeader(filePath, text);
+    if (filter.status && header.status !== filter.status) {
+      continue;
+    }
+    headers.push(header);
+  }
+  headers.sort(compareProject);
+  if (filter.limit && headers.length > filter.limit) {
+    return headers.slice(0, filter.limit);
+  }
+  return headers;
+}
+async function getProjectBySlug(rootDir, slug) {
+  const normalized = slug.trim().toLowerCase();
+  const projects = await listProjectHeaders(rootDir);
+  return projects.find((project) => project.slug.toLowerCase() === normalized) ?? null;
+}
+function toIssueSummary(header) {
+  return {
+    key: header.key,
+    title: header.title,
+    status: header.status,
+    priority: header.priority,
+    projectId: header.projectId
+  };
+}
+async function getBoardView(rootDir, filter = {}) {
+  const limited = await listIssueHeaders(rootDir, filter);
+  const groups = ISSUE_STATUSES.map((status) => ({
+    status,
+    issues: []
+  }));
+  const groupMap = new Map;
+  for (const group of groups) {
+    groupMap.set(group.status, group.issues);
+  }
+  for (const header of limited) {
+    const list = groupMap.get(header.status);
+    if (!list)
+      continue;
+    list.push(toIssueSummary(header));
+  }
+  return { groups };
+}
+async function getProjectsView(rootDir, filter = {}) {
+  const projects = await listProjectHeaders(rootDir, filter);
+  const issues = await listIssueHeaders(rootDir);
+  const counts = new Map;
+  for (const issue of issues) {
+    if (!issue.projectId)
+      continue;
+    counts.set(issue.projectId, (counts.get(issue.projectId) ?? 0) + 1);
+  }
+  const summaries = projects.map((project) => ({
+    slug: project.slug,
+    title: project.title,
+    status: project.status,
+    priority: project.priority,
+    issueCount: project.id ? counts.get(project.id) ?? 0 : 0,
+    id: project.id
+  }));
+  return { projects: summaries };
+}
+function renderBoard(view) {
+  const lines = [];
+  for (const group of view.groups) {
+    lines.push(`${group.status} (${group.issues.length})`);
+    for (const issue of group.issues) {
+      lines.push(`- ${issue.key}: ${issue.title} [${issue.priority}]`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+function renderList(issues) {
+  if (!issues.length) {
+    return "No issues.";
+  }
+  return issues.map((issue) => `- ${issue.key}: ${issue.title} [${issue.status}] [${issue.priority}]`).join(`
+`);
+}
+function renderProjects(view) {
+  if (!view.projects.length) {
+    return "No projects.";
+  }
+  return view.projects.map((project) => `- ${project.slug}: ${project.title} [${project.status}] [${project.priority}] (issues: ${project.issueCount})`).join(`
+`);
+}
+var UUID_V7_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isUuidV7(value) {
+  return UUID_V7_REGEX.test(value);
+}
+function isValidStatus(value) {
+  return !!value && ISSUE_STATUSES.includes(value);
+}
+function isValidPriority(value) {
+  return !!value && PRIORITY_LEVELS.includes(value);
+}
+async function checkWorkspace(rootDir) {
+  const problems = [];
+  const issueFiles = await listIssueFiles(rootDir);
+  const projectFiles = await listProjectFiles(rootDir);
+  const projectIds = new Map;
+  const issueIds = new Map;
+  for (const filePath of projectFiles) {
+    const text = await readTextFile(filePath);
+    const { data, hasFrontmatter, error } = parseFrontmatter(text);
+    if (!hasFrontmatter) {
+      problems.push({ filePath, message: "Missing frontmatter", level: "error" });
+      continue;
+    }
+    if (error) {
+      problems.push({
+        filePath,
+        message: `Frontmatter parse error: ${error.message}`,
+        level: "error"
+      });
+      continue;
+    }
+    const schema = getString(data, "schema");
+    if (schema !== PROJECT_SCHEMA) {
+      problems.push({
+        filePath,
+        message: `Invalid schema (expected ${PROJECT_SCHEMA})`,
+        level: "error"
+      });
+    }
+    const id = getString(data, "id");
+    if (!id) {
+      problems.push({ filePath, message: "Missing id", level: "error" });
+    } else if (!isUuidV7(id)) {
+      problems.push({ filePath, message: "Invalid UUIDv7 id", level: "error" });
+    } else if (projectIds.has(id)) {
+      problems.push({
+        filePath,
+        message: `Duplicate project id (also in ${projectIds.get(id)})`,
+        level: "error"
+      });
+    } else {
+      projectIds.set(id, filePath);
+    }
+    const status = getString(data, "status");
+    if (!isValidStatus(status)) {
+      problems.push({ filePath, message: "Invalid or missing status", level: "error" });
+    }
+    const priority = getString(data, "priority");
+    if (!isValidPriority(priority)) {
+      problems.push({ filePath, message: "Invalid or missing priority", level: "error" });
+    }
+  }
+  for (const filePath of issueFiles) {
+    const text = await readTextFile(filePath);
+    const { data, hasFrontmatter, error } = parseFrontmatter(text);
+    if (!hasFrontmatter) {
+      problems.push({ filePath, message: "Missing frontmatter", level: "error" });
+      continue;
+    }
+    if (error) {
+      problems.push({
+        filePath,
+        message: `Frontmatter parse error: ${error.message}`,
+        level: "error"
+      });
+      continue;
+    }
+    const schema = getString(data, "schema");
+    if (schema !== ISSUE_SCHEMA) {
+      problems.push({
+        filePath,
+        message: `Invalid schema (expected ${ISSUE_SCHEMA})`,
+        level: "error"
+      });
+    }
+    const id = getString(data, "id");
+    if (!id) {
+      problems.push({ filePath, message: "Missing id", level: "error" });
+    } else if (!isUuidV7(id)) {
+      problems.push({ filePath, message: "Invalid UUIDv7 id", level: "error" });
+    } else if (issueIds.has(id)) {
+      problems.push({
+        filePath,
+        message: `Duplicate issue id (also in ${issueIds.get(id)})`,
+        level: "error"
+      });
+    } else {
+      issueIds.set(id, filePath);
+    }
+    const status = getString(data, "status");
+    if (!isValidStatus(status)) {
+      problems.push({ filePath, message: "Invalid or missing status", level: "error" });
+    }
+    const priority = getString(data, "priority");
+    if (!isValidPriority(priority)) {
+      problems.push({ filePath, message: "Invalid or missing priority", level: "error" });
+    }
+    const projectId = getString(data, "projectId");
+    if (projectId && !isUuidV7(projectId)) {
+      problems.push({
+        filePath,
+        message: "projectId is not a UUIDv7",
+        level: "error"
+      });
+    } else if (projectId && !projectIds.has(projectId)) {
+      problems.push({
+        filePath,
+        message: "projectId does not match any project",
+        level: "warning"
+      });
+    }
+  }
+  return { problems, issues: issueFiles.length, projects: projectFiles.length };
+}
+
+// src/workspace.ts
+import * as fs3 from "fs/promises";
+import * as path5 from "path";
+var AGLIT_DIR = ".aglit";
+async function exists(dirPath) {
+  try {
+    await fs3.access(dirPath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function findWorkspaceRoot(startDir) {
+  let current = path5.resolve(startDir);
+  while (true) {
+    if (await exists(path5.join(current, AGLIT_DIR))) {
+      return current;
+    }
+    const parent = path5.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+async function requireWorkspaceRoot(startDir) {
+  const root = await findWorkspaceRoot(startDir);
+  if (!root) {
+    throw new Error("AGLIT not initialized. Run `aglit init`.");
+  }
+  return root;
+}
+
+// src/commands/init.ts
+var initFlags = {
+  prefix: {
+    kind: "parsed",
+    parse: String,
+    brief: "Issue key prefix",
+    optional: true
+  }
+};
+var initCommand = buildCommand({
+  func: async function(flags) {
+    const root = await findWorkspaceRoot(this.cwd) ?? this.cwd;
+    await ensureAglit(root);
+    if (flags.prefix) {
+      await setConfig(root, { issuePrefix: flags.prefix, schema: "aglit.config.v1" });
+    } else {
+      const config = await getConfig(root);
+      if (!config) {
+        throw new Error("Issue prefix required. Run `aglit init --prefix ABC`.");
+      }
+    }
+    this.process.stdout.write(`Initialized AGLIT at ${root}
+`);
+  },
+  parameters: {
+    flags: initFlags
+  },
+  docs: {
+    brief: "Initialize AGLIT in this workspace"
+  }
+});
+
+// src/commands/check.ts
+import * as path7 from "path";
+import { buildCommand as buildCommand2 } from "@stricli/core";
+var checkCommand = buildCommand2({
+  func: async function() {
+    const root = await requireWorkspaceRoot(this.cwd);
+    const report = await checkWorkspace(root);
+    const lines = [];
+    lines.push(`issues: ${report.issues}`);
+    lines.push(`projects: ${report.projects}`);
+    lines.push(`problems: ${report.problems.length}`);
+    if (report.problems.length) {
+      lines.push("");
+      for (const problem of report.problems) {
+        const relative2 = path7.relative(root, problem.filePath) || problem.filePath;
+        lines.push(`- [${problem.level}] ${relative2}: ${problem.message}`);
+      }
+    }
+    this.process.stdout.write(`${lines.join(`
+`)}
+`);
+  },
+  parameters: {},
+  docs: {
+    brief: "Validate AGLIT state"
+  }
+});
+
+// src/commands/list.ts
+import { buildCommand as buildCommand3 } from "@stricli/core";
+var statusParser = (input) => {
+  const value = input.toLowerCase();
+  if (ISSUE_STATUSES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid status: ${input}`);
+};
+var groupParser = (input) => {
+  const value = input.toLowerCase();
+  if (value === "status" || value === "none") {
+    return value;
+  }
+  throw new Error(`Invalid group: ${input}`);
+};
+var listFlags = {
+  status: {
+    kind: "parsed",
+    parse: statusParser,
+    brief: "Filter by status",
+    optional: true
+  },
+  project: {
+    kind: "parsed",
+    parse: String,
+    brief: "Filter by project slug",
+    optional: true
+  },
+  group: {
+    kind: "parsed",
+    parse: groupParser,
+    brief: "Group by status or none",
+    optional: true
+  }
+};
+var listCommand = buildCommand3({
+  func: async function(flags) {
+    const root = await requireWorkspaceRoot(this.cwd);
+    let projectId;
+    if (flags.project) {
+      const project = await getProjectBySlug(root, flags.project);
+      if (!project?.id) {
+        throw new Error(`Project not found or missing id: ${flags.project}`);
+      }
+      projectId = project.id;
+    }
+    const group = flags.group ?? "status";
+    if (group === "none") {
+      const headers = await listIssueHeaders(root, {
+        status: flags.status,
+        projectId
+      });
+      const summaries = headers.map((issue) => ({
+        key: issue.key,
+        title: issue.title,
+        status: issue.status,
+        priority: issue.priority,
+        projectId: issue.projectId
+      }));
+      this.process.stdout.write(`${renderList(summaries)}
+`);
+      return;
+    }
+    const view = await getBoardView(root, {
+      status: flags.status,
+      projectId
+    });
+    this.process.stdout.write(`${renderBoard(view)}
+`);
+  },
+  parameters: {
+    flags: listFlags
+  },
+  docs: {
+    brief: "List issues"
+  }
+});
+
+// src/commands/new.ts
+import { buildCommand as buildCommand4 } from "@stricli/core";
+var statusParser2 = (input) => {
+  const value = input.toLowerCase();
+  if (ISSUE_STATUSES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid status: ${input}`);
+};
+var priorityParser = (input) => {
+  const value = input.toLowerCase();
+  if (PRIORITY_LEVELS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid priority: ${input}`);
+};
+var newFlags = {
+  status: {
+    kind: "parsed",
+    parse: statusParser2,
+    brief: "Issue status",
+    optional: true
+  },
+  priority: {
+    kind: "parsed",
+    parse: priorityParser,
+    brief: "Priority (none|low|medium|high)",
+    optional: true
+  },
+  project: {
+    kind: "parsed",
+    parse: String,
+    brief: "Project slug",
+    optional: true
+  },
+  prefix: {
+    kind: "parsed",
+    parse: String,
+    brief: "Issue key prefix",
+    optional: true
+  }
+};
+var newCommand = buildCommand4({
+  func: async function(flags, title) {
+    const root = await requireWorkspaceRoot(this.cwd);
+    let projectId;
+    if (flags.project) {
+      const project = await getProjectBySlug(root, flags.project);
+      if (!project?.id) {
+        throw new Error(`Project not found or missing id: ${flags.project}`);
+      }
+      projectId = project.id;
+    }
+    const issue = await createIssueFile(root, {
+      title,
+      status: flags.status,
+      priority: flags.priority,
+      projectId,
+      prefix: flags.prefix
+    });
+    this.process.stdout.write(`${issue.key} ${issue.path}
+`);
+  },
+  parameters: {
+    flags: newFlags,
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Issue title",
+          parse: String
+        }
+      ]
+    }
+  },
+  docs: {
+    brief: "Create a new issue"
+  }
+});
+
+// src/commands/project-new.ts
+import { buildCommand as buildCommand5 } from "@stricli/core";
+var statusParser3 = (input) => {
+  const value = input.toLowerCase();
+  if (ISSUE_STATUSES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid status: ${input}`);
+};
+var priorityParser2 = (input) => {
+  const value = input.toLowerCase();
+  if (PRIORITY_LEVELS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid priority: ${input}`);
+};
+var projectNewFlags = {
+  status: {
+    kind: "parsed",
+    parse: statusParser3,
+    brief: "Project status",
+    optional: true
+  },
+  priority: {
+    kind: "parsed",
+    parse: priorityParser2,
+    brief: "Priority (none|low|medium|high)",
+    optional: true
+  },
+  slug: {
+    kind: "parsed",
+    parse: String,
+    brief: "Project slug (optional override)",
+    optional: true
+  }
+};
+var projectNewCommand = buildCommand5({
+  func: async function(flags, title) {
+    const root = await requireWorkspaceRoot(this.cwd);
+    const project = await createProjectFile(root, {
+      title,
+      status: flags.status,
+      priority: flags.priority,
+      slug: flags.slug
+    });
+    this.process.stdout.write(`${project.slug} ${project.path}
+`);
+  },
+  parameters: {
+    flags: projectNewFlags,
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Project title",
+          parse: String
+        }
+      ]
+    }
+  },
+  docs: {
+    brief: "Create a new project"
+  }
+});
+
+// src/commands/projects.ts
+import { buildCommand as buildCommand6 } from "@stricli/core";
+var statusParser4 = (input) => {
+  const value = input.toLowerCase();
+  if (ISSUE_STATUSES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid status: ${input}`);
+};
+var projectsFlags = {
+  status: {
+    kind: "parsed",
+    parse: statusParser4,
+    brief: "Filter by status",
+    optional: true
+  }
+};
+var projectsCommand = buildCommand6({
+  func: async function(flags) {
+    const root = await requireWorkspaceRoot(this.cwd);
+    const view = await getProjectsView(root, { status: flags.status });
+    this.process.stdout.write(`${renderProjects(view)}
+`);
+  },
+  parameters: {
+    flags: projectsFlags
+  },
+  docs: {
+    brief: "List projects"
+  }
+});
+
+// src/routes.ts
+var projectRoutes = buildRouteMap({
+  routes: {
+    new: projectNewCommand
+  },
+  docs: {
+    brief: "Project commands"
+  }
+});
+var routes = buildRouteMap({
+  routes: {
+    init: initCommand,
+    new: newCommand,
+    list: listCommand,
+    projects: projectsCommand,
+    project: projectRoutes,
+    check: checkCommand
+  },
+  docs: {
+    brief: "AGLIT CLI"
+  }
+});
+
+// src/app.ts
+var app = buildApplication(routes, {
+  name: "aglit",
+  scanner: { caseStyle: "allow-kebab-for-camel" }
+});
+
+// src/index.ts
+async function main() {
+  await run(app, process.argv.slice(2), {
+    process,
+    async forCommand() {
+      return { process, cwd: process.cwd() };
+    }
+  });
+}
+main();
+
+//# debugId=FD892239846FB21564756E2164756E21
+//# sourceMappingURL=index.js.map