@sniper.ai/cli 1.0.0 → 2.0.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
-import { defineCommand as defineCommand7, runMain } from "citty";
+import { defineCommand as defineCommand9, runMain } from "citty";
 
 // src/commands/init.ts
 import { defineCommand } from "citty";
@@ -106,9 +106,9 @@ var FRAMEWORK_DIRS = [
 async function ensureDir(dir) {
   await mkdir(dir, { recursive: true });
 }
-async function fileExists(p7) {
+async function fileExists(p9) {
   try {
-    await access2(p7);
+    await access2(p9);
     return true;
   } catch {
     return false;
@@ -117,20 +117,36 @@ async function fileExists(p7) {
 async function scaffoldProject(cwd, config, options = {}) {
   const corePath = getCorePath();
   const sniperDir = join2(cwd, ".sniper");
-  const log7 = [];
+  const log9 = [];
   const isUpdate = options.update === true;
   await ensureDir(sniperDir);
   for (const dir of FRAMEWORK_DIRS) {
     const src = join2(corePath, dir);
     const dest = join2(sniperDir, dir);
     await cp(src, dest, { recursive: true, force: true });
-    log7.push(`Copied ${dir}/`);
+    log9.push(`Copied ${dir}/`);
   }
   await ensureDir(join2(sniperDir, "domain-packs"));
+  const memoryDir = join2(sniperDir, "memory");
+  await ensureDir(memoryDir);
+  await ensureDir(join2(memoryDir, "retros"));
+  const memoryFiles = {
+    "conventions.yaml": "conventions: []\n",
+    "anti-patterns.yaml": "anti_patterns: []\n",
+    "decisions.yaml": "decisions: []\n",
+    "estimates.yaml": "calibration:\n  velocity_factor: 1.0\n  common_underestimates: []\n  last_updated: null\n  sprints_analyzed: 0\n"
+  };
+  for (const [filename, content] of Object.entries(memoryFiles)) {
+    const filePath = join2(memoryDir, filename);
+    if (!isUpdate || !await fileExists(filePath)) {
+      await writeFile2(filePath, content, "utf-8");
+    }
+  }
+  log9.push("Created memory/ directory");
   if (!isUpdate) {
     const configContent = YAML2.stringify(config, { lineWidth: 0 });
     await writeFile2(join2(sniperDir, "config.yaml"), configContent, "utf-8");
-    log7.push("Created config.yaml");
+    log9.push("Created config.yaml");
   }
   if (!isUpdate || !await fileExists(join2(cwd, "CLAUDE.md"))) {
     const claudeTemplate = await readFile2(
@@ -138,9 +154,9 @@ async function scaffoldProject(cwd, config, options = {}) {
       "utf-8"
     );
     await writeFile2(join2(cwd, "CLAUDE.md"), claudeTemplate, "utf-8");
-    log7.push("Created CLAUDE.md");
+    log9.push("Created CLAUDE.md");
   } else {
-    log7.push("Skipped CLAUDE.md (preserved user customizations)");
+    log9.push("Skipped CLAUDE.md (preserved user customizations)");
   }
   const settingsDir = join2(cwd, ".claude");
   await ensureDir(settingsDir);
@@ -154,14 +170,14 @@ async function scaffoldProject(cwd, config, options = {}) {
       settingsTemplate,
       "utf-8"
     );
-    log7.push("Created .claude/settings.json");
+    log9.push("Created .claude/settings.json");
   } else {
-    log7.push("Skipped .claude/settings.json (preserved user customizations)");
+    log9.push("Skipped .claude/settings.json (preserved user customizations)");
   }
   const commandsSrc = join2(corePath, "commands");
   const commandsDest = join2(settingsDir, "commands");
   await cp(commandsSrc, commandsDest, { recursive: true, force: true });
-  log7.push("Copied skills to .claude/commands/");
+  log9.push("Copied skills to .claude/commands/");
   if (!isUpdate) {
     for (const sub of ["epics", "stories", "reviews"]) {
       const dir = join2(cwd, "docs", sub);
@@ -175,9 +191,9 @@ async function scaffoldProject(cwd, config, options = {}) {
         await writeFile2(join2(dir, ".gitkeep"), "", "utf-8");
       }
     }
-    log7.push("Created docs/ directory");
+    log9.push("Created docs/ directory");
   }
-  return log7;
+  return log9;
 }
 
 // src/commands/init.ts
@@ -391,9 +407,9 @@ var initCommand = defineCommand({
     const s = p.spinner();
     s.start("Scaffolding SNIPER project...");
     try {
-      const log7 = await scaffoldProject(cwd, config);
+      const log9 = await scaffoldProject(cwd, config);
       s.stop("Done!");
-      for (const entry of log7) {
+      for (const entry of log9) {
         p.log.success(entry);
       }
       p.outro(
@@ -490,16 +506,16 @@ function assertSafePath(base, untrusted) {
   }
   return full;
 }
-async function pathExists(p7) {
+async function pathExists(p9) {
   try {
-    await access3(p7);
+    await access3(p9);
     return true;
   } catch {
     return false;
   }
 }
-async function readJson(p7) {
-  const raw = await readFile3(p7, "utf-8");
+async function readJson(p9) {
+  const raw = await readFile3(p9, "utf-8");
   return JSON.parse(raw);
 }
 function getPackDir(pkgName, cwd) {
@@ -530,7 +546,7 @@ async function installPack(packageName, cwd) {
   }
   const config = await readConfig(cwd);
   if (!config.domain_packs) config.domain_packs = [];
-  if (!config.domain_packs.some((p7) => p7.name === shortName)) {
+  if (!config.domain_packs.some((p9) => p9.name === shortName)) {
     config.domain_packs.push({ name: shortName, package: packageName });
   }
   await writeConfig(cwd, config);
@@ -544,7 +560,7 @@ async function installPack(packageName, cwd) {
 async function removePack(packName, cwd) {
   const config = await readConfig(cwd);
   const packEntry = (config.domain_packs || []).find(
-    (p7) => p7.name === packName
+    (p9) => p9.name === packName
   );
   const packageName = packEntry?.package || `@sniper.ai/pack-${packName}`;
   const domainPacksDir = join3(cwd, ".sniper", "domain-packs");
@@ -557,7 +573,7 @@ async function removePack(packName, cwd) {
   } catch {
   }
   config.domain_packs = (config.domain_packs || []).filter(
-    (p7) => p7.name !== packName
+    (p9) => p9.name !== packName
   );
   await writeConfig(cwd, config);
 }
@@ -761,9 +777,9 @@ var updateCommand = defineCommand6({
     const s = p6.spinner();
     s.start("Updating framework files...");
     try {
-      const log7 = await scaffoldProject(cwd, currentConfig, { update: true });
+      const log9 = await scaffoldProject(cwd, currentConfig, { update: true });
       s.stop("Done!");
-      for (const entry of log7) {
+      for (const entry of log9) {
         p6.log.success(entry);
       }
       p6.outro("SNIPER updated successfully.");
@@ -775,10 +791,923 @@ var updateCommand = defineCommand6({
   }
 });
 
+// src/commands/memory.ts
+import { readFile as readFile4, writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
+import { join as join4 } from "path";
+import { defineCommand as defineCommand7 } from "citty";
+import * as p7 from "@clack/prompts";
+import YAML4 from "yaml";
+
+// src/fs-utils.ts
+import { mkdir as mkdir3, access as access4 } from "fs/promises";
+async function ensureDir2(dir) {
+  await mkdir3(dir, { recursive: true });
+}
+async function pathExists2(path) {
+  try {
+    await access4(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/memory.ts
+async function readYamlArray(filePath, key) {
+  if (!await pathExists2(filePath)) return [];
+  try {
+    const raw = await readFile4(filePath, "utf-8");
+    const parsed = YAML4.parse(raw);
+    return Array.isArray(parsed?.[key]) ? parsed[key] : [];
+  } catch {
+    return [];
+  }
+}
+async function writeYamlArray(filePath, key, entries) {
+  const content = YAML4.stringify({ [key]: entries }, { lineWidth: 0 });
+  await writeFile3(filePath, content, "utf-8");
+}
+function nextId(entries, prefix) {
+  let max = 0;
+  for (const entry of entries) {
+    const match = entry.id?.match(new RegExp(`^${prefix}-(\\d+)$`));
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > max) max = num;
+    }
+  }
+  return `${prefix}-${String(max + 1).padStart(3, "0")}`;
+}
+var memoryCommand = defineCommand7({
+  meta: {
+    name: "memory",
+    description: "Manage agent memory (conventions, anti-patterns, decisions)"
+  },
+  args: {
+    action: {
+      type: "positional",
+      description: "Action to perform: list, add, remove, promote, export, import",
+      required: false
+    },
+    type: {
+      type: "positional",
+      description: "Memory type: convention, anti-pattern, decision (for add/remove/promote)",
+      required: false
+    },
+    value: {
+      type: "positional",
+      description: "Value for the action (rule text, ID, or file path)",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p7.log.error(
+        'SNIPER is not initialized in this directory. Run "sniper init" first.'
+      );
+      process.exit(1);
+    }
+    const memoryDir = join4(cwd, ".sniper", "memory");
+    if (!await pathExists2(memoryDir)) {
+      await ensureDir2(memoryDir);
+      await ensureDir2(join4(memoryDir, "retros"));
+      await writeFile3(
+        join4(memoryDir, "conventions.yaml"),
+        "conventions: []\n",
+        "utf-8"
+      );
+      await writeFile3(
+        join4(memoryDir, "anti-patterns.yaml"),
+        "anti_patterns: []\n",
+        "utf-8"
+      );
+      await writeFile3(
+        join4(memoryDir, "decisions.yaml"),
+        "decisions: []\n",
+        "utf-8"
+      );
+      await writeFile3(
+        join4(memoryDir, "estimates.yaml"),
+        "calibration:\n  velocity_factor: 1.0\n  common_underestimates: []\n  last_updated: null\n  sprints_analyzed: 0\n",
+        "utf-8"
+      );
+      p7.log.info("Initialized .sniper/memory/ directory");
+    }
+    const conventions = await readYamlArray(
+      join4(memoryDir, "conventions.yaml"),
+      "conventions"
+    );
+    const antiPatterns = await readYamlArray(
+      join4(memoryDir, "anti-patterns.yaml"),
+      "anti_patterns"
+    );
+    const decisions = await readYamlArray(
+      join4(memoryDir, "decisions.yaml"),
+      "decisions"
+    );
+    let retroCount = 0;
+    const retrosDir = join4(memoryDir, "retros");
+    if (await pathExists2(retrosDir)) {
+      const files = await readdir3(retrosDir);
+      retroCount = files.filter((f) => f.endsWith(".yaml")).length;
+    }
+    const action = args.action;
+    if (!action || action === "list") {
+      p7.intro("SNIPER Memory");
+      const confirmedConv = conventions.filter(
+        (c) => c.status !== "candidate"
+      ).length;
+      const candidateConv = conventions.filter(
+        (c) => c.status === "candidate"
+      ).length;
+      const confirmedAp = antiPatterns.filter(
+        (a) => a.status !== "candidate"
+      ).length;
+      const candidateAp = antiPatterns.filter(
+        (a) => a.status === "candidate"
+      ).length;
+      const activeDecisions = decisions.filter(
+        (d) => d.status === "active" || !d.status
+      ).length;
+      const supersededDecisions = decisions.filter(
+        (d) => d.status === "superseded"
+      ).length;
+      p7.log.info(
+        `Conventions:   ${confirmedConv} confirmed, ${candidateConv} candidates`
+      );
+      p7.log.info(
+        `Anti-Patterns: ${confirmedAp} confirmed, ${candidateAp} candidates`
+      );
+      p7.log.info(
+        `Decisions:     ${activeDecisions} active, ${supersededDecisions} superseded`
+      );
+      p7.log.info(`Retrospectives: ${retroCount}`);
+      const config = await readConfig(cwd);
+      if (config.workspace?.enabled && config.workspace.workspace_path) {
+        const wsMemory = join4(
+          cwd,
+          config.workspace.workspace_path,
+          "memory"
+        );
+        if (await pathExists2(wsMemory)) {
+          const wsConv = await readYamlArray(
+            join4(wsMemory, "conventions.yaml"),
+            "conventions"
+          );
+          const wsAp = await readYamlArray(
+            join4(wsMemory, "anti-patterns.yaml"),
+            "anti_patterns"
+          );
+          const wsDec = await readYamlArray(
+            join4(wsMemory, "decisions.yaml"),
+            "decisions"
+          );
+          p7.log.step("Workspace Memory:");
+          p7.log.info(`  Conventions:   ${wsConv.length}`);
+          p7.log.info(`  Anti-Patterns: ${wsAp.length}`);
+          p7.log.info(`  Decisions:     ${wsDec.length}`);
+        }
+      }
+      p7.outro("");
+      return;
+    }
+    if (action === "add") {
+      const type = args.type;
+      const value = args.value;
+      if (!type || !value) {
+        p7.log.error(
+          'Usage: sniper memory add <convention|anti-pattern|decision> "<text>"'
+        );
+        process.exit(1);
+      }
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      if (type === "convention") {
+        const id = nextId(conventions, "conv");
+        conventions.push({
+          id,
+          rule: value,
+          rationale: "",
+          source: { type: "manual", ref: "user-added", date: today },
+          applies_to: [],
+          enforcement: "both",
+          scope: "project",
+          status: "confirmed",
+          examples: { positive: "", negative: "" }
+        });
+        await writeYamlArray(
+          join4(memoryDir, "conventions.yaml"),
+          "conventions",
+          conventions
+        );
+        p7.log.success(`Added convention ${id}: ${value}`);
+      } else if (type === "anti-pattern") {
+        const id = nextId(antiPatterns, "ap");
+        antiPatterns.push({
+          id,
+          description: value,
+          why_bad: "",
+          fix_pattern: "",
+          source: { type: "manual", ref: "user-added", date: today },
+          detection_hint: "",
+          applies_to: [],
+          severity: "medium",
+          status: "confirmed"
+        });
+        await writeYamlArray(
+          join4(memoryDir, "anti-patterns.yaml"),
+          "anti_patterns",
+          antiPatterns
+        );
+        p7.log.success(`Added anti-pattern ${id}: ${value}`);
+      } else if (type === "decision") {
+        const id = nextId(decisions, "dec");
+        decisions.push({
+          id,
+          title: value,
+          context: "",
+          decision: value,
+          alternatives_considered: [],
+          source: { type: "manual", ref: "user-added", date: today },
+          applies_to: [],
+          status: "active",
+          superseded_by: null
+        });
+        await writeYamlArray(
+          join4(memoryDir, "decisions.yaml"),
+          "decisions",
+          decisions
+        );
+        p7.log.success(`Added decision ${id}: ${value}`);
+      } else {
+        p7.log.error(
+          `Unknown memory type "${type}". Use: convention, anti-pattern, decision`
+        );
+        process.exit(1);
+      }
+      return;
+    }
+    if (action === "remove") {
+      const id = args.type;
+      if (!id) {
+        p7.log.error("Usage: sniper memory remove <id>");
+        process.exit(1);
+      }
+      let found = false;
+      if (id.startsWith("conv-")) {
+        const idx = conventions.findIndex((c) => c.id === id);
+        if (idx >= 0) {
+          conventions.splice(idx, 1);
+          await writeYamlArray(
+            join4(memoryDir, "conventions.yaml"),
+            "conventions",
+            conventions
+          );
+          found = true;
+        }
+      } else if (id.startsWith("ap-")) {
+        const idx = antiPatterns.findIndex((a) => a.id === id);
+        if (idx >= 0) {
+          antiPatterns.splice(idx, 1);
+          await writeYamlArray(
+            join4(memoryDir, "anti-patterns.yaml"),
+            "anti_patterns",
+            antiPatterns
+          );
+          found = true;
+        }
+      } else if (id.startsWith("dec-")) {
+        const idx = decisions.findIndex((d) => d.id === id);
+        if (idx >= 0) {
+          decisions.splice(idx, 1);
+          await writeYamlArray(
+            join4(memoryDir, "decisions.yaml"),
+            "decisions",
+            decisions
+          );
+          found = true;
+        }
+      }
+      if (found) {
+        p7.log.success(`Removed ${id}`);
+      } else {
+        p7.log.error(`Entry ${id} not found in memory.`);
+        process.exit(1);
+      }
+      return;
+    }
+    if (action === "promote") {
+      const id = args.type;
+      if (!id) {
+        p7.log.error("Usage: sniper memory promote <id>");
+        process.exit(1);
+      }
+      let found = false;
+      if (id.startsWith("conv-")) {
+        const entry = conventions.find((c) => c.id === id);
+        if (entry && entry.status === "candidate") {
+          entry.status = "confirmed";
+          await writeYamlArray(
+            join4(memoryDir, "conventions.yaml"),
+            "conventions",
+            conventions
+          );
+          found = true;
+        }
+      } else if (id.startsWith("ap-")) {
+        const entry = antiPatterns.find((a) => a.id === id);
+        if (entry && entry.status === "candidate") {
+          entry.status = "confirmed";
+          await writeYamlArray(
+            join4(memoryDir, "anti-patterns.yaml"),
+            "anti_patterns",
+            antiPatterns
+          );
+          found = true;
+        }
+      } else if (id.startsWith("dec-")) {
+        const entry = decisions.find((d) => d.id === id);
+        if (entry && entry.status === "candidate") {
+          entry.status = "active";
+          await writeYamlArray(
+            join4(memoryDir, "decisions.yaml"),
+            "decisions",
+            decisions
+          );
+          found = true;
+        }
+      }
+      if (found) {
+        p7.log.success(`Promoted ${id} to confirmed/active`);
+      } else {
+        p7.log.error(
+          `Entry ${id} not found or is not a candidate.`
+        );
+        process.exit(1);
+      }
+      return;
+    }
+    if (action === "export") {
+      const exportData = {
+        exported_from: (await readConfig(cwd)).project.name,
+        exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+        version: "1.0",
+        conventions: conventions.map(({ id: _id, source: _src, ...rest }) => rest),
+        anti_patterns: antiPatterns.map(
+          ({ id: _id, source: _src, ...rest }) => rest
+        ),
+        decisions: decisions.map(({ id: _id, source: _src, ...rest }) => rest)
+      };
+      const exportPath = join4(cwd, "sniper-memory-export.yaml");
+      await writeFile3(
+        exportPath,
+        YAML4.stringify(exportData, { lineWidth: 0 }),
+        "utf-8"
+      );
+      p7.log.success(
+        `Exported ${conventions.length} conventions, ${antiPatterns.length} anti-patterns, ${decisions.length} decisions to sniper-memory-export.yaml`
+      );
+      return;
+    }
+    if (action === "import") {
+      const filePath = args.type;
+      if (!filePath) {
+        p7.log.error("Usage: sniper memory import <file>");
+        process.exit(1);
+      }
+      const raw = await readFile4(join4(cwd, filePath), "utf-8");
+      const imported = YAML4.parse(raw);
+      let addedConv = 0;
+      let addedAp = 0;
+      let skipped = 0;
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      if (Array.isArray(imported.conventions)) {
+        for (const conv of imported.conventions) {
+          const exists = conventions.some(
+            (c) => c.rule === conv.rule
+          );
+          if (exists) {
+            skipped++;
+            continue;
+          }
+          conventions.push({
+            ...conv,
+            id: nextId(conventions, "conv"),
+            source: { type: "imported", ref: filePath, date: today },
+            status: "candidate"
+          });
+          addedConv++;
+        }
+        await writeYamlArray(
+          join4(memoryDir, "conventions.yaml"),
+          "conventions",
+          conventions
+        );
+      }
+      if (Array.isArray(imported.anti_patterns)) {
+        for (const ap of imported.anti_patterns) {
+          const exists = antiPatterns.some(
+            (a) => a.description === ap.description
+          );
+          if (exists) {
+            skipped++;
+            continue;
+          }
+          antiPatterns.push({
+            ...ap,
+            id: nextId(antiPatterns, "ap"),
+            source: { type: "imported", ref: filePath, date: today },
+            status: "candidate"
+          });
+          addedAp++;
+        }
+        await writeYamlArray(
+          join4(memoryDir, "anti-patterns.yaml"),
+          "anti_patterns",
+          antiPatterns
+        );
+      }
+      p7.log.success(
+        `Imported ${addedConv} conventions, ${addedAp} anti-patterns (${skipped} skipped as duplicates)`
+      );
+      return;
+    }
+    p7.log.error(
+      `Unknown action "${action}". Use: list, add, remove, promote, export, import`
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/workspace.ts
+import {
+  readFile as readFile5,
+  writeFile as writeFile4,
+  readdir as readdir4,
+  stat as stat2,
+  symlink
+} from "fs/promises";
+import { join as join5, relative, resolve as resolve2 } from "path";
+import { defineCommand as defineCommand8 } from "citty";
+import * as p8 from "@clack/prompts";
+import YAML5 from "yaml";
+var initSubCommand = defineCommand8({
+  meta: {
+    name: "init",
+    description: "Initialize a SNIPER workspace"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    if (await pathExists2(join5(cwd, "workspace.yaml"))) {
+      const raw = await readFile5(join5(cwd, "workspace.yaml"), "utf-8");
+      const ws = YAML5.parse(raw);
+      p8.log.warn(
+        `A workspace already exists: ${ws.name} (${ws.repositories.length} repos)`
+      );
+      p8.log.info("Use /sniper-workspace status to view details.");
+      process.exit(0);
+    }
+    p8.intro("Initialize SNIPER Workspace");
+    const name = await p8.text({
+      message: "Workspace name:",
+      placeholder: "my-saas-platform"
+    });
+    if (p8.isCancel(name)) {
+      p8.cancel("Aborted.");
+      process.exit(0);
+    }
+    const description = await p8.text({
+      message: "Description:",
+      placeholder: "Multi-service SaaS platform"
+    });
+    if (p8.isCancel(description)) {
+      p8.cancel("Aborted.");
+      process.exit(0);
+    }
+    const s = p8.spinner();
+    s.start("Scanning for SNIPER-enabled repositories...");
+    const parentDir = resolve2(cwd, "..");
+    const repos = [];
+    try {
+      const siblings = await readdir4(parentDir);
+      for (const entry of siblings) {
+        const entryPath = join5(parentDir, entry);
+        const entryStat = await stat2(entryPath);
+        if (!entryStat.isDirectory()) continue;
+        if (resolve2(entryPath) === resolve2(cwd)) continue;
+        const configPath = join5(entryPath, ".sniper", "config.yaml");
+        if (await pathExists2(configPath)) {
+          try {
+            const raw = await readFile5(configPath, "utf-8");
+            const config = YAML5.parse(raw);
+            repos.push({
+              name: config.project?.name || entry,
+              path: relative(cwd, entryPath),
+              role: inferRole(config.project?.type),
+              language: config.stack?.language || "unknown",
+              sniper_enabled: true,
+              exposes: [],
+              consumes: []
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    s.stop(`Found ${repos.length} SNIPER-enabled repositories`);
+    if (repos.length === 0) {
+      p8.log.warn(
+        "No SNIPER-enabled repositories found in sibling directories."
+      );
+      p8.log.info(
+        'Initialize SNIPER in your repos first with "sniper init", or add repos manually later.'
+      );
+    } else {
+      for (const repo of repos) {
+        p8.log.info(`  ${repo.name} (${repo.role}, ${repo.language}) ${repo.path}`);
+      }
+    }
+    const depGraph = {};
+    for (const repo of repos) {
+      depGraph[repo.name] = [];
+    }
+    const workspace = {
+      name,
+      description,
+      version: "1.0",
+      repositories: repos,
+      dependency_graph: depGraph,
+      config: {
+        contract_format: "yaml",
+        integration_validation: true,
+        shared_domain_packs: [],
+        memory: {
+          workspace_conventions: true,
+          auto_promote: false
+        }
+      },
+      state: {
+        feature_counter: 1,
+        features: []
+      }
+    };
+    await writeFile4(
+      join5(cwd, "workspace.yaml"),
+      YAML5.stringify(workspace, { lineWidth: 0 }),
+      "utf-8"
+    );
+    await ensureDir2(join5(cwd, "memory"));
+    await writeFile4(
+      join5(cwd, "memory", "conventions.yaml"),
+      "conventions: []\n",
+      "utf-8"
+    );
+    await writeFile4(
+      join5(cwd, "memory", "anti-patterns.yaml"),
+      "anti_patterns: []\n",
+      "utf-8"
+    );
+    await writeFile4(
+      join5(cwd, "memory", "decisions.yaml"),
+      "decisions: []\n",
+      "utf-8"
+    );
+    await ensureDir2(join5(cwd, "contracts"));
+    await writeFile4(join5(cwd, "contracts", ".gitkeep"), "", "utf-8");
+    await ensureDir2(join5(cwd, "features"));
+    await writeFile4(join5(cwd, "features", ".gitkeep"), "", "utf-8");
+    if (repos.length > 0) {
+      await ensureDir2(join5(cwd, "repositories"));
+      for (const repo of repos) {
+        const linkPath = join5(cwd, "repositories", repo.name);
+        const targetPath = resolve2(cwd, repo.path);
+        if (!await pathExists2(linkPath)) {
+          try {
+            await symlink(targetPath, linkPath);
+          } catch {
+          }
+        }
+      }
+    }
+    for (const repo of repos) {
+      const repoDir = resolve2(cwd, repo.path);
+      try {
+        const config = await readConfig(repoDir);
+        config.workspace = {
+          enabled: true,
+          workspace_path: relative(repoDir, cwd),
+          repo_name: repo.name
+        };
+        await writeConfig(repoDir, config);
+      } catch {
+        p8.log.warn(`Could not update config for ${repo.name}`);
+      }
+    }
+    p8.log.success("Workspace initialized!");
+    p8.log.info(`  Location: ${cwd}`);
+    p8.log.info(`  Repos: ${repos.length}`);
+    p8.log.info("");
+    p8.log.info("Next steps:");
+    p8.log.info(
+      '  /sniper-workspace feature "description"  \u2014 Plan a cross-repo feature'
+    );
+    p8.log.info(
+      "  /sniper-workspace status                 \u2014 View workspace status"
+    );
+    p8.outro("");
+  }
+});
+var statusSubCommand = defineCommand8({
+  meta: {
+    name: "status",
+    description: "Show workspace status"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    const wsPath = join5(cwd, "workspace.yaml");
+    if (!await pathExists2(wsPath)) {
+      p8.log.error(
+        "No workspace found. Run /sniper-workspace init to create one."
+      );
+      process.exit(1);
+    }
+    const raw = await readFile5(wsPath, "utf-8");
+    const ws = YAML5.parse(raw);
+    p8.intro(`Workspace: ${ws.name}`);
+    p8.log.info(ws.description);
+    p8.log.step("Repositories:");
+    for (const repo of ws.repositories) {
+      const repoPath = resolve2(cwd, repo.path);
+      const accessible = await pathExists2(repoPath);
+      const icon = accessible ? "\u2713" : "\u2717";
+      p8.log.info(
+        `  ${icon} ${repo.name.padEnd(20)} ${repo.role.padEnd(12)} ${repo.language}`
+      );
+    }
+    const activeFeatures = ws.state.features.filter(
+      (f) => f.phase !== "complete"
+    );
+    if (activeFeatures.length > 0) {
+      p8.log.step("Active Features:");
+      for (const f of activeFeatures) {
+        p8.log.info(
+          `  ${f.id}  "${f.title}"  Phase: ${f.phase}${f.sprint_wave ? `  Wave: ${f.sprint_wave}` : ""}`
+        );
+      }
+    } else {
+      p8.log.step("No active workspace features.");
+    }
+    const contractsDir = join5(cwd, "contracts");
+    if (await pathExists2(contractsDir)) {
+      const files = (await readdir4(contractsDir)).filter(
+        (f) => f.endsWith(".contract.yaml")
+      );
+      if (files.length > 0) {
+        p8.log.step("Contracts:");
+        for (const file of files) {
+          try {
+            const cRaw = await readFile5(join5(contractsDir, file), "utf-8");
+            const contract = YAML5.parse(cRaw);
+            const name = contract.contract?.name || file;
+            const version2 = contract.contract?.version || "?";
+            const between = contract.contract?.between?.join(" \u2194 ") || "?";
+            p8.log.info(`  ${name}  v${version2}  ${between}`);
+          } catch {
+            p8.log.info(`  ${file}  (parse error)`);
+          }
+        }
+      } else {
+        p8.log.step("No contracts defined.");
+      }
+    }
+    const memDir = join5(cwd, "memory");
+    if (await pathExists2(memDir)) {
+      const convFile = join5(memDir, "conventions.yaml");
+      const apFile = join5(memDir, "anti-patterns.yaml");
+      const decFile = join5(memDir, "decisions.yaml");
+      let convCount = 0;
+      let apCount = 0;
+      let decCount = 0;
+      if (await pathExists2(convFile)) {
+        try {
+          const parsed = YAML5.parse(await readFile5(convFile, "utf-8"));
+          convCount = Array.isArray(parsed?.conventions) ? parsed.conventions.length : 0;
+        } catch {
+        }
+      }
+      if (await pathExists2(apFile)) {
+        try {
+          const parsed = YAML5.parse(await readFile5(apFile, "utf-8"));
+          apCount = Array.isArray(parsed?.anti_patterns) ? parsed.anti_patterns.length : 0;
+        } catch {
+        }
+      }
+      if (await pathExists2(decFile)) {
+        try {
+          const parsed = YAML5.parse(await readFile5(decFile, "utf-8"));
+          decCount = Array.isArray(parsed?.decisions) ? parsed.decisions.length : 0;
+        } catch {
+        }
+      }
+      p8.log.step("Workspace Memory:");
+      p8.log.info(`  Conventions:   ${convCount}`);
+      p8.log.info(`  Anti-Patterns: ${apCount}`);
+      p8.log.info(`  Decisions:     ${decCount}`);
+    }
+    p8.outro("");
+  }
+});
+var addRepoSubCommand = defineCommand8({
+  meta: {
+    name: "add-repo",
+    description: "Add a repository to the workspace"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to the repository",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    const wsPath = join5(cwd, "workspace.yaml");
+    if (!await pathExists2(wsPath)) {
+      p8.log.error("No workspace found. Run /sniper-workspace init first.");
+      process.exit(1);
+    }
+    const repoPath = resolve2(cwd, args.path);
+    if (!await sniperConfigExists(repoPath)) {
+      p8.log.error(
+        `${repoPath} is not a SNIPER-enabled project. Run "sniper init" in that directory first.`
+      );
+      process.exit(1);
+    }
+    const repoConfig = await readConfig(repoPath);
+    const raw = await readFile5(wsPath, "utf-8");
+    const ws = YAML5.parse(raw);
+    const repoName = repoConfig.project.name;
+    if (ws.repositories.some((r) => r.name === repoName)) {
+      p8.log.warn(`Repository "${repoName}" is already in the workspace.`);
+      process.exit(0);
+    }
+    ws.repositories.push({
+      name: repoName,
+      path: relative(cwd, repoPath),
+      role: inferRole(repoConfig.project.type),
+      language: repoConfig.stack.language,
+      sniper_enabled: true,
+      exposes: [],
+      consumes: []
+    });
+    ws.dependency_graph[repoName] = [];
+    await writeFile4(wsPath, YAML5.stringify(ws, { lineWidth: 0 }), "utf-8");
+    repoConfig.workspace = {
+      enabled: true,
+      workspace_path: relative(repoPath, cwd),
+      repo_name: repoName
+    };
+    await writeConfig(repoPath, repoConfig);
+    p8.log.success(
+      `Added ${repoName} (${repoConfig.project.type}, ${repoConfig.stack.language})`
+    );
+  }
+});
+var removeRepoSubCommand = defineCommand8({
+  meta: {
+    name: "remove-repo",
+    description: "Remove a repository from the workspace"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Repository name",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    const wsPath = join5(cwd, "workspace.yaml");
+    if (!await pathExists2(wsPath)) {
+      p8.log.error("No workspace found.");
+      process.exit(1);
+    }
+    const raw = await readFile5(wsPath, "utf-8");
+    const ws = YAML5.parse(raw);
+    const repoName = args.name;
+    const idx = ws.repositories.findIndex((r) => r.name === repoName);
+    if (idx < 0) {
+      p8.log.error(`Repository "${repoName}" not found in workspace.`);
+      process.exit(1);
+    }
+    const repo = ws.repositories[idx];
+    ws.repositories.splice(idx, 1);
+    delete ws.dependency_graph[repoName];
+    for (const deps of Object.values(ws.dependency_graph)) {
+      const depIdx = deps.indexOf(repoName);
+      if (depIdx >= 0) deps.splice(depIdx, 1);
+    }
+    await writeFile4(wsPath, YAML5.stringify(ws, { lineWidth: 0 }), "utf-8");
+    const repoPath = resolve2(cwd, repo.path);
+    try {
+      const repoConfig = await readConfig(repoPath);
+      repoConfig.workspace = {
+        enabled: false,
+        workspace_path: null,
+        repo_name: null
+      };
+      await writeConfig(repoPath, repoConfig);
+    } catch {
+    }
+    p8.log.success(`Removed ${repoName} from workspace.`);
+  }
+});
+var validateSubCommand = defineCommand8({
+  meta: {
+    name: "validate",
+    description: "Validate interface contracts against implementations"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    const wsPath = join5(cwd, "workspace.yaml");
+    if (!await pathExists2(wsPath)) {
+      p8.log.error("No workspace found.");
+      process.exit(1);
+    }
+    const contractsDir = join5(cwd, "contracts");
+    if (!await pathExists2(contractsDir)) {
+      p8.log.error("No contracts/ directory found.");
+      process.exit(1);
+    }
+    const files = (await readdir4(contractsDir)).filter(
+      (f) => f.endsWith(".contract.yaml")
+    );
+    if (files.length === 0) {
+      p8.log.info("No contracts found. Create them with /sniper-workspace feature.");
+      process.exit(0);
+    }
+    p8.intro("Contract Validation");
+    for (const file of files) {
+      try {
+        const raw = await readFile5(join5(contractsDir, file), "utf-8");
+        const contract = YAML5.parse(raw);
+        const name = contract.contract?.name || file;
+        const version2 = contract.contract?.version || "?";
+        const endpoints = contract.endpoints?.length || 0;
+        const types = contract.shared_types?.length || 0;
+        const events = contract.events?.length || 0;
+        p8.log.info(
+          `${name} v${version2}: ${endpoints} endpoints, ${types} types, ${events} events`
+        );
+        p8.log.info(
+          "  (Structural validation requires running /sniper-workspace validate as a slash command)"
+        );
+      } catch {
+        p8.log.warn(`  ${file}: parse error`);
+      }
+    }
+    p8.log.info(
+      "\nFull validation (endpoint/type/event checking) runs via the /sniper-workspace validate slash command."
+    );
+    p8.outro("");
+  }
+});
+function inferRole(projectType) {
+  switch (projectType) {
+    case "saas":
+    case "web":
+    case "mobile":
+      return "frontend";
+    case "api":
+      return "backend";
+    case "library":
+      return "library";
+    case "cli":
+    case "monorepo":
+      return "service";
+    default:
+      return "service";
+  }
+}
+var workspaceCommand = defineCommand8({
+  meta: {
+    name: "workspace",
+    description: "Manage SNIPER workspaces for multi-project orchestration"
+  },
+  subCommands: {
+    init: initSubCommand,
+    status: statusSubCommand,
+    "add-repo": addRepoSubCommand,
+    "remove-repo": removeRepoSubCommand,
+    validate: validateSubCommand
+  }
+});
+
 // src/index.ts
 var require2 = createRequire2(import.meta.url);
 var { version } = require2("../package.json");
-var main = defineCommand7({
+var main = defineCommand9({
   meta: {
     name: "sniper",
     version,
@@ -790,7 +1719,9 @@ var main = defineCommand7({
     "add-pack": addPackCommand,
     "remove-pack": removePackCommand,
     "list-packs": listPacksCommand,
-    update: updateCommand
+    update: updateCommand,
+    memory: memoryCommand,
+    workspace: workspaceCommand
   }
 });
 runMain(main);