@structured-vibe-coding/core 0.17.1 → 0.18.0

package/dist/{chunk-EPFURATC.js → chunk-O5SP6X5R.js}

@@ -1,3 +1,73 @@
+// src/paths.ts
+import { join } from "pathe";
+var SDD_DIR = ".sdd";
+function sddRoot(projectRoot) {
+  return join(projectRoot, SDD_DIR);
+}
+function configPath(projectRoot) {
+  return join(sddRoot(projectRoot), "config.yaml");
+}
+function workflowsDir(projectRoot) {
+  return join(sddRoot(projectRoot), "workflows");
+}
+function templatesDir(projectRoot) {
+  return join(sddRoot(projectRoot), "templates");
+}
+function memoryDir(projectRoot, config) {
+  return join(projectRoot, config.memory_path);
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return value.slice(0, end);
+}
+function memoryPathRel(config) {
+  return stripTrailingSlashes(config.memory_path) || "memory";
+}
+function changesPathRel(config) {
+  return stripTrailingSlashes(config.changes_path) || "changes";
+}
+function displayArchivePath(config, changeId) {
+  return `${stripTrailingSlashes(config.archive_path) || "archive"}/${changeId}`;
+}
+function displayChangePath(config, changeId) {
+  return `${changesPathRel(config)}/${changeId}`;
+}
+function guidancePaths(config) {
+  const memory = memoryPathRel(config);
+  const changes = changesPathRel(config);
+  return {
+    memory,
+    changes,
+    constitution: `${memory}/constitution.md`,
+    memoryIndex: `${memory}/index.md`
+  };
+}
+function changesDir(projectRoot, config) {
+  return join(projectRoot, config.changes_path);
+}
+function archiveDir(projectRoot, config) {
+  return join(projectRoot, config.archive_path);
+}
+function domainsDir(projectRoot, config) {
+  return join(projectRoot, config.domains_path);
+}
+function changePath(projectRoot, config, changeId) {
+  return join(changesDir(projectRoot, config), changeId);
+}
+function changeMetaPath(projectRoot, config, changeId) {
+  return join(changePath(projectRoot, config, changeId), "meta.yaml");
+}
+function activePointerPath(projectRoot, config) {
+  return join(changesDir(projectRoot, config), ".active");
+}
+function searchConfigPath(projectRoot) {
+  return join(sddRoot(projectRoot), "search.yaml");
+}
+function indexDbPath(projectRoot) {
+  return join(sddRoot(projectRoot), "index.db");
+}
+
 // src/fs.ts
 import { promises as fs } from "fs";
 import { dirname } from "pathe";
@@ -81,6 +151,25 @@ async function removePath(path) {
 }
 
 export {
+  SDD_DIR,
+  sddRoot,
+  configPath,
+  workflowsDir,
+  templatesDir,
+  memoryDir,
+  memoryPathRel,
+  changesPathRel,
+  displayArchivePath,
+  displayChangePath,
+  guidancePaths,
+  changesDir,
+  archiveDir,
+  domainsDir,
+  changePath,
+  changeMetaPath,
+  activePointerPath,
+  searchConfigPath,
+  indexDbPath,
   pathExists,
   ensureDir,
   readText,

package/dist/{chunk-BGM6KS64.js → chunk-QGP43XCN.js}

@@ -2,7 +2,7 @@ import {
   interpolate,
   interpolateArgs,
   loadMcpConfig
-} from "./chunk-KYWETNFU.js";
+} from "./chunk-4BRO7BOJ.js";
 import {
   SddError
 } from "./chunk-MHODNFIL.js";
@@ -26,7 +26,7 @@ function toProcessEnv(base, extra) {
 }
 
 // src/version.ts
-var SDD_CORE_VERSION = "0.17.1" ? "0.17.1" : "0.0.0-dev";
+var SDD_CORE_VERSION = "0.18.0" ? "0.18.0" : "0.0.0-dev";
 
 // src/mcp/client.ts
 function mcpTimeoutMs() {

package/dist/{chunk-A752UVPF.js → chunk-QHV5KZKX.js}

@@ -1,28 +1,198 @@
-import {
-  ChangeMetaSchema,
-  WorkflowSchema
-} from "./chunk-67AUAGNV.js";
 import {
   activePointerPath,
   changeMetaPath,
   changePath,
   changesDir,
-  workflowsDir
-} from "./chunk-7MJYPJMR.js";
-import {
+  displayChangePath,
   ensureDir,
   listDirs,
   listFiles,
   pathExists,
   readText,
   readYaml,
+  workflowsDir,
   writeText,
   writeYaml
-} from "./chunk-EPFURATC.js";
+} from "./chunk-O5SP6X5R.js";
+
+// src/schemas.ts
+import { z } from "zod";
+var GateSchema = z.object({
+  type: z.enum(["none", "soft", "hard"]).default("soft"),
+  mode: z.enum(["none", "human_approval", "checklist"]).default("checklist"),
+  checklist: z.array(z.string()).default([]),
+  overridable: z.boolean().default(true)
+});
+var ArtifactDefSchema = z.object({
+  id: z.string(),
+  path: z.string(),
+  template: z.string().optional(),
+  required: z.boolean().default(true)
+});
+var VerifyCommandSchema = z.object({
+  name: z.string(),
+  run: z.string(),
+  required: z.boolean().default(false)
+});
+var StageSchema = z.object({
+  id: z.string(),
+  title: z.string().optional(),
+  summary: z.string().optional(),
+  /**
+   * standard — normal work stage
+   * brainstorm — optional multi-approach exploration (before design)
+   * clarify — optional Q&A before leaving a major stage
+   */
+  kind: z.enum(["standard", "brainstorm", "clarify"]).default("standard"),
+  /** When true, stage is optional (skippable); agents may skip if not needed */
+  optional: z.boolean().default(false),
+  artifacts: z.array(ArtifactDefSchema).default([]),
+  gate: GateSchema.default({}),
+  skippable: z.boolean().default(true),
+  skip_when: z.object({
+    flags: z.array(z.string()).optional()
+  }).optional(),
+  verify: z.object({
+    commands: z.array(VerifyCommandSchema).default([]),
+    evidence_dir: z.string().optional()
+  }).optional(),
+  agent_context: z.object({
+    include: z.array(z.string()).default([]),
+    instructions: z.string().optional()
+  }).optional()
+});
+var WorkflowSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  version: z.number().default(1),
+  stages: z.array(StageSchema).min(1),
+  recommendation: z.object({
+    when: z.object({
+      labels: z.array(z.string()).optional(),
+      keywords: z.array(z.string()).optional(),
+      max_complexity: z.enum(["low", "medium", "high"]).optional(),
+      min_complexity: z.enum(["low", "medium", "high"]).optional()
+    }).optional(),
+    priority: z.number().default(0)
+  }).optional(),
+  on_complete: z.object({
+    archive: z.boolean().default(false),
+    domain_sync: z.enum(["never", "recommend", "require"]).default("never")
+  }).optional()
+});
+var ConfigSchema = z.object({
+  version: z.number().default(1),
+  metrics: z.object({
+    enabled: z.boolean().default(true),
+    exclude: z.array(z.string().min(1)).default([])
+  }).default({}),
+  memory_path: z.string().default("memory"),
+  changes_path: z.string().default("changes"),
+  archive_path: z.string().default("archive"),
+  domains_path: z.string().default("domains"),
+  default_workflow: z.string().default("recommend"),
+  allowed_workflows: z.array(z.string()).optional(),
+  per_change: z.object({
+    allow_skip: z.boolean().default(true),
+    allow_gate_override: z.enum(["true", "false", "soft_only"]).default("soft_only"),
+    allow_custom_stages: z.boolean().default(true),
+    require_reason_on_skip: z.boolean().default(true)
+  }).default({}),
+  persistence: z.object({
+    default: z.enum(["change_only", "domain_sync"]).default("change_only"),
+    archive_on_complete: z.boolean().default(false),
+    domain_sync: z.object({
+      mode: z.enum(["never", "recommend", "require"]).default("never"),
+      anchored_domains: z.array(z.string()).default([])
+    }).default({})
+  }).default({}),
+  policy: z.object({
+    gates: z.enum(["soft", "hard"]).default("soft")
+  }).default({})
+});
+var ChangeMetaSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  workflow: z.string(),
+  created: z.string(),
+  updated: z.string().optional(),
+  status: z.enum(["in_progress", "blocked", "completed", "abandoned"]).default("in_progress"),
+  stage: z.string(),
+  branch: z.string().optional(),
+  /** Epic key such as issue-37. Stories in one epic share a dependency graph. */
+  epic: z.string().optional(),
+  /** Story id such as S-001. */
+  story: z.string().optional(),
+  depends: z.array(z.string()).optional(),
+  domain: z.string().optional(),
+  flags: z.record(z.union([z.boolean(), z.string(), z.number()])).default({}),
+  overrides: z.object({
+    skip_stages: z.array(z.string()).default([]),
+    gates: z.record(z.enum(["none", "soft", "hard"])).default({}),
+    extra_stages: z.array(StageSchema).default([])
+  }).default({}),
+  skipped: z.array(
+    z.object({
+      stage: z.string(),
+      reason: z.string(),
+      at: z.string()
+    })
+  ).default([]),
+  gates: z.record(
+    z.object({
+      status: z.enum(["pending", "approved", "failed", "waived"]),
+      note: z.string().optional(),
+      at: z.string().optional()
+    })
+  ).default({}),
+  /** Results from `sdd verify` keyed by stage id */
+  verify_results: z.record(
+    z.object({
+      ok: z.boolean(),
+      /** pass | fail | not_run (absent in metas written before 0.17.3) */
+      status: z.enum(["pass", "fail", "not_run"]).optional(),
+      head_sha: z.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i).optional(),
+      at: z.string(),
+      results: z.array(
+        z.object({
+          name: z.string(),
+          exitCode: z.number().nullable()
+        })
+      ).default([])
+    })
+  ).default({}),
+  pr: z.object({
+    number: z.number().optional(),
+    url: z.string().optional()
+  }).optional(),
+  completed_at: z.string().optional()
+});
 
 // src/slug.ts
+var SLUG_MAX = 60;
+function trailingIssueRef(input) {
+  return input.match(/#\s*(\d+)\s*\)?\s*$/)?.[1];
+}
 function slugify(input) {
-  return input.toLowerCase().trim().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
+  const normalized = input.toLowerCase().trim().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (normalized.length <= SLUG_MAX) return normalized;
+  const issue = trailingIssueRef(input);
+  const tokens = normalized.split("-").filter(Boolean);
+  const body = issue && tokens.at(-1) === issue ? tokens.slice(0, -1) : tokens;
+  const reserve = issue && issue.length <= SLUG_MAX ? issue.length + 1 : 0;
+  const kept = [];
+  let length = 0;
+  for (const token of body) {
+    const next = length === 0 ? token.length : length + 1 + token.length;
+    if (next + reserve > SLUG_MAX) break;
+    kept.push(token);
+    length = next;
+  }
+  if (reserve && issue) {
+    if (kept.length === 0) return issue;
+    return `${kept.join("-")}-${issue}`;
+  }
+  return kept.join("-");
 }
 function todayIsoDate(d = /* @__PURE__ */ new Date()) {
   return d.toISOString().slice(0, 10);
@@ -232,6 +402,7 @@ async function buildContext(projectRoot, config, changeId) {
   return {
     id: changeId,
     path: changePath(projectRoot, config, changeId),
+    displayPath: displayChangePath(config, changeId),
     meta,
     workflow,
     stages: resolveStages(workflow, meta),
@@ -252,20 +423,7 @@ async function getActiveChangeId(projectRoot, config) {
       await writeText(pointer, "");
     }
   }
-  const all = await listChanges(projectRoot, config);
-  const inProgress = [];
-  for (const id of all) {
-    try {
-      const meta = await loadChangeMeta(projectRoot, config, id);
-      if (meta.status === "in_progress" || meta.status === "blocked") {
-        inProgress.push({ id, updated: meta.updated ?? meta.created });
-      }
-    } catch {
-    }
-  }
-  if (!inProgress.length) return null;
-  inProgress.sort((a, b) => b.updated.localeCompare(a.updated));
-  return inProgress[0].id;
+  return null;
 }
 async function clearActiveIf(projectRoot, config, changeId) {
   const pointer = activePointerPath(projectRoot, config);
@@ -290,6 +448,18 @@ async function resolveChangeId(projectRoot, config, changeId) {
 }
 
 export {
+  GateSchema,
+  ArtifactDefSchema,
+  VerifyCommandSchema,
+  StageSchema,
+  WorkflowSchema,
+  ConfigSchema,
+  ChangeMetaSchema,
+  slugify,
+  todayIsoDate,
+  nowIso,
+  changeDirName,
+  uniqueChangeDirName,
   listWorkflowNames,
   loadWorkflow,
   resolveStages,
@@ -301,11 +471,6 @@ export {
   firstActiveStageId,
   inferComplexity,
   recommendWorkflow,
-  slugify,
-  todayIsoDate,
-  nowIso,
-  changeDirName,
-  uniqueChangeDirName,
   loadChangeMeta,
   saveChangeMeta,
   buildContext,

package/dist/{gather-S4A5YR7X.js → gather-ZNV2NAUN.js}

@@ -3,11 +3,10 @@ import {
   gatherMcpContext,
   gatherMcpContextForChange,
   listMatchingSourceIds
-} from "./chunk-BGM6KS64.js";
-import "./chunk-KYWETNFU.js";
+} from "./chunk-QGP43XCN.js";
+import "./chunk-4BRO7BOJ.js";
 import "./chunk-MHODNFIL.js";
-import "./chunk-7MJYPJMR.js";
-import "./chunk-EPFURATC.js";
+import "./chunk-O5SP6X5R.js";
 export {
   formatMcpContextForHandoff,
   gatherMcpContext,

package/dist/{greenfield-QQJH3XL3.js → greenfield-I5S5OS2D.js}

@@ -6,12 +6,11 @@ import {
   startFeatureFromBacklog,
   startGreenfield,
   updateFeatureStatus
-} from "./chunk-72QJHR53.js";
-import "./chunk-WPAGUBZ5.js";
-import "./chunk-A752UVPF.js";
-import "./chunk-67AUAGNV.js";
-import "./chunk-7MJYPJMR.js";
-import "./chunk-EPFURATC.js";
+} from "./chunk-LHSR7JG2.js";
+import "./chunk-44LQ5BKZ.js";
+import "./chunk-QHV5KZKX.js";
+import "./chunk-MHODNFIL.js";
+import "./chunk-O5SP6X5R.js";
 export {
   findFeaturesBacklogPath,
   listBacklogFeatures,