@structured-vibe-coding/core 0.17.1 → 0.18.0

package/dist/chunk-BVCTVKBD.js

@@ -1,538 +0,0 @@
-import {
-  buildAgentPrompt,
-  formatStatus
-} from "./chunk-WPAGUBZ5.js";
-import {
-  loadConfig
-} from "./chunk-WHDG6OTG.js";
-import {
-  buildContext,
-  getActiveChangeId
-} from "./chunk-A752UVPF.js";
-import {
-  sddRoot
-} from "./chunk-7MJYPJMR.js";
-import {
-  pathExists,
-  readText,
-  removePath,
-  writeText
-} from "./chunk-EPFURATC.js";
-
-// src/agents.ts
-import { join } from "pathe";
-var AGENT_INTEGRATIONS = [
-  {
-    id: "copilot",
-    key: "copilot",
-    aliases: ["github-copilot", "gh-copilot"],
-    label: "GitHub Copilot",
-    hint: ".github/agents/*.agent.md (VS Code, Cursor, JetBrains, \u2026)",
-    requiresCli: false,
-    installUrl: "https://github.com/features/copilot",
-    rolePath: (roleId) => `.github/agents/${roleId}.agent.md`,
-    agentsMdRow: "| GitHub Copilot | `.github/agents/*.agent.md` (same roles; any IDE that supports Copilot agents) |"
-  },
-  {
-    id: "claude-code",
-    key: "claude",
-    aliases: ["claude-code", "claudecode"],
-    label: "Claude Code",
-    hint: ".claude/agents/*.md (terminal agent)",
-    requiresCli: true,
-    cliBinary: "claude",
-    installUrl: "https://docs.anthropic.com/en/docs/claude-code",
-    rolePath: (roleId) => `.claude/agents/${roleId}.md`,
-    agentsMdRow: "| Claude Code | `.claude/agents/` (`sdd`, `sdd-planner`, `sdd-implementer`, `sdd-reviewer`) |"
-  },
-  {
-    id: "grok",
-    key: "grok",
-    aliases: ["grok-build", "grokbuild", "xai", "xai-grok"],
-    label: "Grok Build",
-    hint: ".grok/rules/sdd.md + AGENTS.md (terminal TUI from xAI)",
-    requiresCli: false,
-    cliBinary: "grok",
-    installUrl: "https://docs.x.ai",
-    // Single rules file: Grok auto-loads all .grok/rules/*.md
-    rolePath: () => `.grok/rules/sdd.md`,
-    rolesToInstall: ["sdd"],
-    agentsMdRow: "| Grok Build | `.grok/rules/sdd.md` + `AGENTS.md` (reads protocol + active-context; run `sdd` in shell) |"
-  },
-  {
-    id: "ollama",
-    key: "ollama",
-    aliases: ["local", "llama", "ollama-local"],
-    label: "Ollama (local)",
-    hint: "Local models via `ollama` CLI + AGENTS.md / .ollama/sdd.md (set SDD_OLLAMA_MODEL)",
-    requiresCli: true,
-    cliBinary: "ollama",
-    installUrl: "https://ollama.com",
-    // Single project brief — Ollama does not auto-load multi-role agent trees
-    rolePath: () => `.ollama/sdd.md`,
-    rolesToInstall: ["sdd"],
-    agentsMdRow: "| Ollama (local) | `.ollama/sdd.md` + `AGENTS.md` + handoff; launch: `ollama run $SDD_OLLAMA_MODEL` |"
-  },
-  {
-    id: "kilo",
-    key: "kilo",
-    aliases: ["kilocode", "kilo-code", "kilo-ai"],
-    label: "Kilo Code",
-    hint: ".kilo/sdd.md + AGENTS.md (terminal CLI from kilo.ai)",
-    requiresCli: true,
-    cliBinary: "kilo",
-    installUrl: "https://kilo.ai/docs/code-with-ai/platforms/cli",
-    // Single project brief — Kilo loads AGENTS.md and supports instruction files
-    rolePath: () => `.kilo/sdd.md`,
-    rolesToInstall: ["sdd"],
-    agentsMdRow: "| Kilo Code | `.kilo/sdd.md` + `AGENTS.md` (reads protocol + active-context; run `kilo` or `sdd` in shell) |"
-  }
-];
-var ALL_AGENT_TARGETS = AGENT_INTEGRATIONS.map((i) => i.id);
-var DEFAULT_INIT_INTEGRATION = "copilot";
-var AGENT_TARGET_OPTIONS = AGENT_INTEGRATIONS.map(
-  ({ id, key, label, hint, requiresCli, installUrl }) => ({
-    id,
-    key,
-    label,
-    hint,
-    requiresCli,
-    installUrl
-  })
-);
-var IDE_NAMES = /* @__PURE__ */ new Set(["intellij", "idea", "jetbrains", "vscode", "vs-code", "cursor"]);
-function getIntegration(target) {
-  const found = AGENT_INTEGRATIONS.find((i) => i.id === target);
-  if (!found) throw new Error(`Unknown agent integration: ${target}`);
-  return found;
-}
-function integrationKeyFor(target) {
-  return getIntegration(target).key;
-}
-function optionForTarget(target) {
-  return getIntegration(target);
-}
-function agentHostPaths(target) {
-  switch (target) {
-    case "copilot":
-      return [".github/agents"];
-    case "claude-code":
-      return [".claude/agents"];
-    case "grok":
-      return [".grok/rules"];
-    case "ollama":
-      return [".ollama"];
-    case "kilo":
-      return [".kilo"];
-    default:
-      return [];
-  }
-}
-var LEGACY_AGENT_PATHS = [".idea/sdd-agent-notes.md"];
-async function removeOtherAgentHosts(projectRoot, keep) {
-  const removed = [];
-  for (const integ of AGENT_INTEGRATIONS) {
-    if (integ.id === keep) continue;
-    for (const rel of agentHostPaths(integ.id)) {
-      const full = join(projectRoot, rel);
-      if (await pathExists(full)) {
-        await removePath(full);
-        removed.push(rel);
-      }
-    }
-  }
-  for (const rel of LEGACY_AGENT_PATHS) {
-    const full = join(projectRoot, rel);
-    if (await pathExists(full)) {
-      await removePath(full);
-      removed.push(rel);
-    }
-  }
-  for (const parent of [".claude", ".idea", ".grok", ".ollama", ".kilo"]) {
-    if (keep === "grok" && parent === ".grok") continue;
-    if (keep === "ollama" && parent === ".ollama") continue;
-    if (keep === "kilo" && parent === ".kilo") continue;
-    const full = join(projectRoot, parent);
-    if (!await pathExists(full)) continue;
-    try {
-      const { readdir } = await import("fs/promises");
-      const kids = await readdir(full);
-      if (kids.length === 0) {
-        await removePath(full);
-        removed.push(parent);
-      }
-    } catch {
-    }
-  }
-  return removed;
-}
-function parseIntegration(raw) {
-  const p = raw.trim().toLowerCase();
-  if (!p) {
-    throw new Error(
-      `Expected one AI coding agent. Choose from: ${AGENT_INTEGRATIONS.map((i) => i.key).join(", ")}`
-    );
-  }
-  if (IDE_NAMES.has(p)) {
-    throw new Error(
-      `"${p}" is an IDE, not an AI coding agent. Choose: ${AGENT_INTEGRATIONS.map((i) => i.key).join(", ")}.`
-    );
-  }
-  for (const integ of AGENT_INTEGRATIONS) {
-    if (integ.id === p || integ.key === p || integ.aliases.includes(p)) {
-      return integ.id;
-    }
-  }
-  throw new Error(
-    `Unknown AI coding agent "${raw}". Choose from: ${AGENT_INTEGRATIONS.map((i) => i.key).join(", ")}`
-  );
-}
-function parseAgentTargets(raw) {
-  const parts = (Array.isArray(raw) ? raw : [raw]).flatMap((s) => String(s).split(",")).map((s) => s.trim()).filter(Boolean);
-  if (!parts.length) {
-    throw new Error("No AI coding agent specified");
-  }
-  const out = [];
-  for (const p of parts) {
-    const id = parseIntegration(p);
-    if (!out.includes(id)) out.push(id);
-  }
-  return out;
-}
-var SDD_AGENT_ROLES = [
-  {
-    id: "sdd",
-    description: "Default SDD agent. Use for any Spec-Driven Development work on the active change pack.",
-    roleLine: "Router: inspect stage in active-context; plan or implement accordingly.",
-    roleRules: [
-      "If stage is intent/feature/design/tasks/stories/research: act as planner (artifacts, little or no product code).",
-      "If stage is implement: act as implementer (scoped code only).",
-      "If stage is local_verify: act as reviewer (gaps vs acceptance; fixes only).",
-      "If kickoff/brief says refine or analyze: follow changes/<id>/refine-brief.md \u2014 stage-scoped refine; never edit constitution; do not sdd next."
-    ]
-  },
-  {
-    id: "sdd-planner",
-    description: "SDD planner. Use when filling intent, design, research, stories, or tasks \u2014 not large code changes.",
-    roleLine: "Planner: produce/update stage markdown only.",
-    roleRules: [
-      "Do not make large product code changes unless the user explicitly overrides.",
-      "Keep artifacts short and actionable."
-    ]
-  },
-  {
-    id: "sdd-implementer",
-    description: "SDD implementer. Use when coding the active change (implement stage).",
-    roleLine: "Implementer: code only for the active change pack.",
-    roleRules: [
-      "Follow tasks.md / acceptance; honor arb-decision and design constraints.",
-      "Do not expand scope beyond the change title/intent."
-    ]
-  },
-  {
-    id: "sdd-reviewer",
-    description: "SDD reviewer. Use before verify/complete or to check work against the change pack.",
-    roleLine: "Reviewer: compare work to acceptance and stage artifacts.",
-    roleRules: [
-      "List gaps; suggest minimal fixes only.",
-      "Remind user to run sdd verify before sdd complete."
-    ]
-  }
-];
-async function installAgentIntegration(opts) {
-  const integ = getIntegration(opts.target);
-  const created = [];
-  const skipped = [];
-  const root = opts.projectRoot;
-  const force = opts.force ?? false;
-  await removeOtherAgentHosts(root, opts.target);
-  const write = async (rel, content) => {
-    const full = join(root, rel);
-    if (await pathExists(full) && !force) {
-      skipped.push(rel);
-      return;
-    }
-    await writeText(full, content);
-    created.push(rel);
-  };
-  await write(join(".sdd", "protocol.md"), PROTOCOL_MD);
-  await refreshActiveAgentContext(root);
-  const roles = integ.rolesToInstall?.length ? SDD_AGENT_ROLES.filter((r) => integ.rolesToInstall.includes(r.id)) : SDD_AGENT_ROLES;
-  for (const role of roles) {
-    await write(integ.rolePath(role.id), renderThinAgent(role));
-  }
-  await write("AGENTS.md", renderAgentsMd(integ));
-  await write(
-    join(".sdd", "agents.json"),
-    JSON.stringify(
-      {
-        version: 3,
-        mode: "agents-only",
-        protocol: ".sdd/protocol.md",
-        activeContext: ".sdd/active-context.md",
-        roles: SDD_AGENT_ROLES.map((r) => r.id),
-        /** Speckit-style public key */
-        ai: integ.key,
-        integration: integ.key,
-        installed: [integ.id],
-        updated: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      null,
-      2
-    ) + "\n"
-  );
-  return { created, skipped, target: opts.target };
-}
-async function installAgentIntegrations(opts) {
-  if (!opts.targets?.length) {
-    throw new Error(
-      `Specify one AI coding agent: ${AGENT_INTEGRATIONS.map((i) => i.key).join(", ")}`
-    );
-  }
-  const created = [];
-  const skipped = [];
-  for (const target of opts.targets) {
-    const r = await installAgentIntegration({
-      projectRoot: opts.projectRoot,
-      target,
-      force: opts.force
-    });
-    created.push(...r.created);
-    skipped.push(...r.skipped);
-  }
-  return { created, skipped, targets: opts.targets };
-}
-function renderThinAgent(role) {
-  const rules = role.roleRules.map((r) => `- ${r}`).join("\n");
-  return `---
-name: ${role.id}
-description: ${role.description}
----
-
-# ${role.id}
-
-${role.roleLine}
-
-## Required reads (in order)
-
-1. \`.sdd/active-context.md\` \u2014 current change and stage
-2. \`.sdd/protocol.md\` \u2014 SDD rules for this repo (single playbook)
-3. \`memory/constitution.md\` if present \u2014 non-negotiables
-4. Active change files under \`changes/<id>/\` as listed in active-context
-
-## Role rules
-
-${rules}
-
-## Done
-
-Remind the human: \`sdd verify\` then \`sdd next\` / \`sdd complete\` as appropriate.
-Do not claim the change is complete without local verification when the workflow requires it.
-`;
-}
-async function loadInstalledAgent(projectRoot) {
-  const path = join(sddRoot(projectRoot), "agents.json");
-  if (!await pathExists(path)) return null;
-  try {
-    const raw = JSON.parse(await readText(path));
-    const key = raw.ai ?? raw.integration ?? raw.installed?.[0];
-    if (!key || typeof key !== "string") return null;
-    const target = parseIntegration(key);
-    return { ai: integrationKeyFor(target), target, integration: getIntegration(target) };
-  } catch {
-    return null;
-  }
-}
-async function writeAgentHandoff(projectRoot, config, changeId) {
-  const ctx = await buildContext(projectRoot, config, changeId);
-  const body = await buildAgentPrompt(ctx, config, projectRoot);
-  const outPath = join(sddRoot(projectRoot), "handoff.md");
-  const header = `# SDD handoff (auto)
-
-> Generated for the AI coding agent configured at init.  
-> Change: **${ctx.meta.title}** \xB7 \`${ctx.id}\` \xB7 stage **${ctx.meta.stage}**
-
-Also read: \`.sdd/active-context.md\`, \`.sdd/protocol.md\`, \`memory/constitution.md\` if present.
-
----
-
-`;
-  await writeText(outPath, header + body + "\n");
-  return outPath;
-}
-function agentKickoffMessage(opts) {
-  const event = opts.event ?? "context updated";
-  if (opts.instructions?.trim()) {
-    return [
-      `SDD: ${event}.`,
-      `Title: ${opts.title}`,
-      `Change: ${opts.changeId}`,
-      `Stage: ${opts.stage}`,
-      opts.instructions.trim()
-    ].join(" ");
-  }
-  return [
-    `SDD: ${event}.`,
-    `Title: ${opts.title}`,
-    `Change: ${opts.changeId}`,
-    `Stage: ${opts.stage}`,
-    `Read in order: .sdd/active-context.md, .sdd/handoff.md, .sdd/protocol.md, memory/constitution.md (if present).`,
-    `Do the work for the current stage only under changes/${opts.changeId}/. Do not expand scope.`,
-    `When the stage is done, tell the human to run: sdd next (or sdd verify / sdd complete as appropriate).`
-  ].join(" ");
-}
-async function refreshActiveAgentContext(projectRoot) {
-  const markerDir = sddRoot(projectRoot);
-  if (!await pathExists(join(markerDir, "config.yaml"))) {
-    return null;
-  }
-  const protocolPath = join(markerDir, "protocol.md");
-  if (!await pathExists(protocolPath)) {
-    await writeText(protocolPath, PROTOCOL_MD);
-  }
-  const config = await loadConfig(projectRoot);
-  const activeId = await getActiveChangeId(projectRoot, config);
-  const outPath = join(markerDir, "active-context.md");
-  if (!activeId) {
-    const empty = `# SDD active context
-
-_No active change._ Run \`sdd new "\u2026"\` or **SDD: New Change** in the IDE.
-
-Then re-run \`sdd agents refresh\` (or advance a stage) to update this file.
-
-Protocol: \`.sdd/protocol.md\`
-`;
-    await writeText(outPath, empty);
-    return outPath;
-  }
-  const ctx = await buildContext(projectRoot, config, activeId);
-  const handoff = await buildAgentPrompt(ctx, config, projectRoot);
-  const status = formatStatus(ctx);
-  const body = `# SDD active context
-
-> Auto-generated for coding agents.  
-> Change: **${ctx.meta.title}** \xB7 \`${ctx.id}\` \xB7 stage **${ctx.meta.stage}**  
-> Protocol: \`.sdd/protocol.md\`
-
-## Status
-
-\`\`\`
-${status}
-\`\`\`
-
-${handoff}
-`;
-  await writeText(outPath, body);
-  return outPath;
-}
-var PROTOCOL_MD = `# SDD protocol
-
-This repo uses **Structured Vibe Coding** (\`sdd\`). Agents must follow this file plus \`.sdd/active-context.md\`. Do not invent a parallel process.
-
-## Source of truth
-
-| What | Where |
-|------|--------|
-| Process state | \`changes/<id>/meta.yaml\` (workflow, stage, gates) |
-| Current task snapshot | \`.sdd/active-context.md\` |
-| Non-negotiables | \`memory/constitution.md\` if present |
-| Stable product/tech rules | \`memory/*.md\` (start at \`memory/index.md\` if present) |
-| Stage artifacts | files in \`changes/<id>/\` for the active change |
-
-## Required read order
-
-1. \`.sdd/active-context.md\`
-2. This file (\`.sdd/protocol.md\`)
-3. \`memory/constitution.md\` if present (non-negotiables agents must not violate)
-4. \`meta.yaml\` + artifacts for the **current stage** (and prior stages if needed)
-5. \`memory/index.md\` (documentation map) if present, then linked memory pages when architecture or conventions matter
-
-## Stage behavior
-
-| Stage kind | Agent focus |
-|------------|-------------|
-| intent / feature / stories | Clarify scope; write short artifacts |
-| design / lld / db / research / hl_arb | Specs and decisions; minimal product code |
-| tasks | Break work into implementable checklist |
-| implement | Code only for this change; follow tasks/acceptance |
-| local_verify | Check acceptance; fix only; prepare for complete |
-| brainstorm (optional) | Multiple approaches; parallel exploration; no final design yet |
-| clarify_* (optional) | Ask clarifying questions; write Q&A; or tell human to skip |
-
-## Optional stages
-
-- Stages marked **optional** / kind \`brainstorm\` or \`clarify\` may be skipped:  
-  \`sdd skip <stage_id> -r "not needed"\`
-- Do **not** invent a skip by jumping stages. \`sdd next\` blocks on empty required stubs (e.g. design.md).
-- If the tool falls back to an earlier stage, **complete that stage** before advancing again.
-
-## Hard rules
-
-1. **Do not skip hard gates.** If blocked, tell the human to run \`sdd gate approve\` (or fix the gate).
-2. **Stay in scope** of the active change title/intent. No drive-by refactors or new features.
-3. **Honor constraints** in \`arb-decision.md\`, design, and memory non-negotiables.
-4. **Local verify** is part of done when the workflow has a verify stage: \`sdd verify\`.
-5. Prefer small, reviewable diffs.
-6. **Required stage artifacts must be substantive** \u2014 not empty templates. Design cannot be skipped via empty design.md.
-
-## Commands (human / shell)
-
-\`\`\`bash
-sdd status
-sdd next
-sdd agent              # print handoff
-sdd agents refresh     # refresh active-context.md
-sdd verify
-sdd complete
-\`\`\`
-
-## Out of scope for agents
-
-- Replacing CI/CD or team process tools
-- Deleting \`.sdd\` / completed change history
-- Claiming complete without verify when required
-`;
-function renderAgentsMd(integ) {
-  return `# Agents
-
-This repo uses **SDD agents only** (no skills).
-
-AI coding agents are **not** the same as IDEs: VS Code, Cursor, and IntelliJ host tools like Copilot or Claude Code.
-
-| Read first | |
-|------------|--|
-| Live task | \`.sdd/active-context.md\` |
-| Playbook | \`.sdd/protocol.md\` |
-| Constitution | \`memory/constitution.md\` if present |
-| Doc map (stable) | \`memory/index.md\` if present |
-
-| AI agent | Files |
-|----------|--------|
-${integ.agentsMdRow}
-
-Refresh context: \`sdd agents refresh\`.
-`;
-}
-
-export {
-  AGENT_INTEGRATIONS,
-  ALL_AGENT_TARGETS,
-  DEFAULT_INIT_INTEGRATION,
-  AGENT_TARGET_OPTIONS,
-  getIntegration,
-  integrationKeyFor,
-  optionForTarget,
-  agentHostPaths,
-  removeOtherAgentHosts,
-  parseIntegration,
-  parseAgentTargets,
-  SDD_AGENT_ROLES,
-  installAgentIntegration,
-  installAgentIntegrations,
-  renderThinAgent,
-  loadInstalledAgent,
-  writeAgentHandoff,
-  agentKickoffMessage,
-  refreshActiveAgentContext,
-  PROTOCOL_MD
-};

package/dist/chunk-WHDG6OTG.js

@@ -1,46 +0,0 @@
-import {
-  ConfigSchema
-} from "./chunk-67AUAGNV.js";
-import {
-  SddError
-} from "./chunk-MHODNFIL.js";
-import {
-  configPath,
-  sddRoot
-} from "./chunk-7MJYPJMR.js";
-import {
-  ensureDir,
-  pathExists,
-  readYaml,
-  writeYaml
-} from "./chunk-EPFURATC.js";
-
-// 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 SddError(`SDD is not initialized in ${projectRoot}. Run \`sdd init\` first.`, {
-      code: "NOT_INITIALIZED",
-      hint: "cd into your app and run: sdd init --here --ai copilot"
-    });
-  }
-  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 {
-  isInitialized,
-  loadConfig,
-  saveConfig,
-  defaultConfig
-};