@structured-vibe-coding/core 0.9.0 → 0.10.0

package/README.md

@@ -2,10 +2,7 @@
 
 Core engine for **Structured Vibe Coding** — local-first Spec-Driven Development.
 
-Used by:
-
-- `@structured-vibe-coding/cli` (`sdd` command)
-- VS Code / Cursor extension (`packages/vscode`)
+Used by `@structured-vibe-coding/cli` (`sdd` command).
 
 ## Install
 

package/dist/{agents-BA7WVN35.js → agents-IB37YJX6.js}

@@ -19,7 +19,10 @@ import {
   removeOtherAgentHosts,
   renderThinAgent,
   writeAgentHandoff
-} from "./chunk-M245MC6E.js";
+} from "./chunk-UAOFNSLQ.js";
+import "./chunk-KZHNYGD6.js";
+import "./chunk-7MJYPJMR.js";
+import "./chunk-EPFURATC.js";
 export {
   AGENT_INTEGRATIONS,
   AGENT_TARGET_OPTIONS,

package/dist/chunk-7MJYPJMR.js

@@ -0,0 +1,51 @@
+// 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 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");
+}
+
+export {
+  SDD_DIR,
+  sddRoot,
+  configPath,
+  workflowsDir,
+  templatesDir,
+  memoryDir,
+  changesDir,
+  archiveDir,
+  domainsDir,
+  changePath,
+  changeMetaPath,
+  activePointerPath
+};

package/dist/chunk-EPFURATC.js

@@ -0,0 +1,96 @@
+// src/fs.ts
+import { promises as fs } from "fs";
+import { dirname } from "pathe";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+async function pathExists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  await fs.mkdir(path, { recursive: true });
+}
+async function readText(path) {
+  return fs.readFile(path, "utf8");
+}
+async function writeText(path, content) {
+  await ensureDir(dirname(path));
+  await fs.writeFile(path, content, "utf8");
+}
+async function readYaml(path) {
+  const raw = await readText(path);
+  return parseYaml(raw);
+}
+async function writeYaml(path, data) {
+  const content = stringifyYaml(data, {
+    lineWidth: 100,
+    defaultStringType: "PLAIN",
+    defaultKeyType: "PLAIN"
+  });
+  await writeText(path, content.endsWith("\n") ? content : `${content}
+`);
+}
+async function listDirs(path) {
+  if (!await pathExists(path)) return [];
+  const entries = await fs.readdir(path, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function listFiles(path) {
+  if (!await pathExists(path)) return [];
+  const entries = await fs.readdir(path, { withFileTypes: true });
+  return entries.filter((e) => e.isFile()).map((e) => e.name);
+}
+async function copyDir(src, dest) {
+  await ensureDir(dest);
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const from = `${src}/${entry.name}`;
+    const to = `${dest}/${entry.name}`;
+    if (entry.isDirectory()) {
+      await copyDir(from, to);
+    } else {
+      await ensureDir(dirname(to));
+      await fs.copyFile(from, to);
+    }
+  }
+}
+async function copyDirSkipExisting(src, dest) {
+  await ensureDir(dest);
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const from = `${src}/${entry.name}`;
+    const to = `${dest}/${entry.name}`;
+    if (entry.isDirectory()) {
+      await copyDirSkipExisting(from, to);
+    } else if (!await pathExists(to)) {
+      await ensureDir(dirname(to));
+      await fs.copyFile(from, to);
+    }
+  }
+}
+async function writeTextIfMissing(path, content) {
+  if (await pathExists(path)) return false;
+  await writeText(path, content);
+  return true;
+}
+async function removePath(path) {
+  await fs.rm(path, { recursive: true, force: true });
+}
+
+export {
+  pathExists,
+  ensureDir,
+  readText,
+  writeText,
+  readYaml,
+  writeYaml,
+  listDirs,
+  listFiles,
+  copyDir,
+  copyDirSkipExisting,
+  writeTextIfMissing,
+  removePath
+};

package/dist/chunk-KZHNYGD6.js

@@ -0,0 +1,187 @@
+import {
+  configPath,
+  sddRoot
+} from "./chunk-7MJYPJMR.js";
+import {
+  ensureDir,
+  pathExists,
+  readYaml,
+  writeYaml
+} from "./chunk-EPFURATC.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),
+  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(),
+  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(),
+      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/config.ts
+async function isInitialized(projectRoot) {
+  return pathExists(configPath(projectRoot));
+}
+async function loadConfig(projectRoot) {
+  const path = configPath(projectRoot);
+  if (!await pathExists(path)) {
+    throw new Error(
+      `SDD is not initialized in ${projectRoot}. Run \`sdd init\` first.`
+    );
+  }
+  const raw = await readYaml(path);
+  return ConfigSchema.parse(raw);
+}
+async function saveConfig(projectRoot, config) {
+  await ensureDir(sddRoot(projectRoot));
+  await writeYaml(configPath(projectRoot), ConfigSchema.parse(config));
+}
+function defaultConfig() {
+  return ConfigSchema.parse({});
+}
+
+export {
+  GateSchema,
+  ArtifactDefSchema,
+  VerifyCommandSchema,
+  StageSchema,
+  WorkflowSchema,
+  ConfigSchema,
+  ChangeMetaSchema,
+  isInitialized,
+  loadConfig,
+  saveConfig,
+  defaultConfig
+};