@outcomeeng/spx 0.1.7 → 0.2.0

package/dist/cli.js

@@ -817,6 +817,42 @@ async function resolveSessionConfig(options = {}) {
   };
 }
 
+// src/session/batch.ts
+var BatchError = class extends Error {
+  results;
+  constructor(results) {
+    const failures = results.filter((r) => !r.ok);
+    const successes = results.filter((r) => r.ok);
+    super(
+      `${failures.length} of ${results.length} operations failed. ${successes.length} succeeded.`
+    );
+    this.name = "BatchError";
+    this.results = results;
+  }
+};
+async function processBatch(ids, handler) {
+  const results = [];
+  for (const id of ids) {
+    try {
+      const output2 = await handler(id);
+      results.push({ id, ok: true, message: output2 });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({ id, ok: false, message });
+    }
+  }
+  const output = results.map((r) => r.ok ? r.message : `Error (${r.id}): ${r.message}`).join("\n\n");
+  const hasFailures = results.some((r) => !r.ok);
+  if (hasFailures) {
+    const err = new BatchError(results);
+    err.message = `${err.message}
+
+${output}`;
+    throw err;
+  }
+  return output;
+}
+
 // src/session/errors.ts
 var SessionError = class extends Error {
   constructor(message) {
@@ -908,14 +944,17 @@ async function resolveArchivePaths(sessionId, config) {
   }
   throw new SessionNotFoundError(sessionId);
 }
-async function archiveCommand(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
-  const { source, target } = await resolveArchivePaths(options.sessionId, config);
+async function archiveSingle(sessionId, config) {
+  const { source, target } = await resolveArchivePaths(sessionId, config);
   await mkdir(dirname2(target), { recursive: true });
   await rename(source, target);
-  return `Archived session: ${options.sessionId}
+  return `Archived session: ${sessionId}
 Archive location: ${target}`;
 }
+async function archiveCommand(options) {
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  return processBatch(options.sessionIds, (id) => archiveSingle(id, config));
+}
 
 // src/commands/session/delete.ts
 import { stat as stat2, unlink } from "fs/promises";
@@ -1108,13 +1147,16 @@ async function findExistingPaths(paths) {
   }
   return existing;
 }
-async function deleteCommand(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
-  const paths = resolveSessionPaths(options.sessionId, config);
+async function deleteSingle(sessionId, config) {
+  const paths = resolveSessionPaths(sessionId, config);
   const existingPaths = await findExistingPaths(paths);
-  const pathToDelete = resolveDeletePath(options.sessionId, existingPaths);
+  const pathToDelete = resolveDeletePath(sessionId, existingPaths);
   await unlink(pathToDelete);
-  return `Deleted session: ${options.sessionId}`;
+  return `Deleted session: ${sessionId}`;
+}
+async function deleteCommand(options) {
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  return processBatch(options.sessionIds, (id) => deleteSingle(id, config));
 }
 
 // src/commands/session/handoff.ts
@@ -1511,16 +1553,19 @@ async function findExistingPath(paths, _config) {
   }
   return null;
 }
-async function showCommand(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
-  const paths = resolveSessionPaths(options.sessionId, config);
+async function showSingle(sessionId, config) {
+  const paths = resolveSessionPaths(sessionId, config);
   const found = await findExistingPath(paths, config);
   if (!found) {
-    throw new SessionNotFoundError(options.sessionId);
+    throw new SessionNotFoundError(sessionId);
   }
   const content = await readFile4(found.path, "utf-8");
   return formatShowOutput(content, { status: found.status });
 }
+async function showCommand(options) {
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  return processBatch(options.sessionIds, (id) => showSingle(id, config));
+}
 
 // src/domains/session/help.ts
 var SESSION_FORMAT_HELP = `
@@ -1539,7 +1584,8 @@ Workflow:
   1. handoff  - Create session (todo)
   2. pickup   - Claim session (todo -> doing)
   3. release  - Return session (doing -> todo)
-  4. delete   - Remove session
+  4. archive  - Move session to archive
+  5. delete   - Remove session permanently
 `;
 var HANDOFF_FRONTMATTER_HELP = `
 Usage:
@@ -1627,10 +1673,10 @@ function registerSessionCommands(sessionCmd) {
       handleError(error);
     }
   });
-  sessionCmd.command("show <id>").description("Show session content").option("--sessions-dir <path>", "Custom sessions directory").action(async (id, options) => {
+  sessionCmd.command("show <id...>").description("Show session content").option("--sessions-dir <path>", "Custom sessions directory").action(async (ids, options) => {
     try {
       const output = await showCommand({
-        sessionId: id,
+        sessionIds: ids,
         sessionsDir: options.sessionsDir
       });
       console.log(output);
@@ -1677,10 +1723,10 @@ function registerSessionCommands(sessionCmd) {
       handleError(error);
     }
   });
-  sessionCmd.command("delete <id>").description("Delete a session").option("--sessions-dir <path>", "Custom sessions directory").action(async (id, options) => {
+  sessionCmd.command("delete <id...>").description("Delete one or more sessions").option("--sessions-dir <path>", "Custom sessions directory").action(async (ids, options) => {
     try {
       const output = await deleteCommand({
-        sessionId: id,
+        sessionIds: ids,
         sessionsDir: options.sessionsDir
       });
       console.log(output);
@@ -1705,10 +1751,10 @@ function registerSessionCommands(sessionCmd) {
       handleError(error);
     }
   });
-  sessionCmd.command("archive <id>").description("Move a session to the archive directory").option("--sessions-dir <path>", "Custom sessions directory").action(async (id, options) => {
+  sessionCmd.command("archive <id...>").description("Move one or more sessions to the archive directory").option("--sessions-dir <path>", "Custom sessions directory").action(async (ids, options) => {
     try {
       const output = await archiveCommand({
-        sessionId: id,
+        sessionIds: ids,
         sessionsDir: options.sessionsDir
       });
       console.log(output);
@@ -1730,6 +1776,10 @@ var sessionDomain = {
   }
 };
 
+// src/domains/spec/index.ts
+import { access as access2 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+
 // src/scanner/scanner.ts
 import path5 from "path";
 var Scanner = class {
@@ -2287,6 +2337,226 @@ This command is for legacy specs/ projects. For CODE framework projects, check t
   }
 }
 
+// src/spec/apply/exclude/adapters/detect.ts
+import { join as join8 } from "path";
+
+// src/spec/apply/exclude/constants.ts
+var SPX_PREFIX = "spx/";
+var NODE_SUFFIXES = [".outcome/", ".enabler/", ".capability/", ".feature/", ".story/"];
+var COMMENT_CHAR = "#";
+var EXCLUDE_FILENAME = "EXCLUDE";
+
+// src/spec/apply/exclude/mappings.ts
+function toPytestIgnore(node) {
+  return `--ignore=${SPX_PREFIX}${node}/`;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+}
+function toMypyRegex(node) {
+  const escaped = escapeRegex(`${SPX_PREFIX}${node}/`);
+  return `^${escaped}`;
+}
+function toPyrightPath(node) {
+  return `${SPX_PREFIX}${node}/`;
+}
+function isExcludedEntry(val) {
+  const hasPrefix = val.includes(SPX_PREFIX);
+  const hasSuffix = NODE_SUFFIXES.some((suffix) => val.includes(suffix));
+  return hasPrefix && hasSuffix;
+}
+
+// src/spec/apply/exclude/adapters/python.ts
+var PYTHON_CONFIG_FILE = "pyproject.toml";
+var PYTEST_SECTION = "tool.pytest.ini_options";
+var MYPY_SECTION = "tool.mypy";
+var PYRIGHT_SECTION = "tool.pyright";
+var ARRAY_INDENT = "    ";
+function updatePytestAddopts(content, nodes) {
+  const sectionPattern = new RegExp(`^\\[${PYTEST_SECTION.replace(/\./g, "\\.")}\\]`, "m");
+  const sectionMatch = sectionPattern.exec(content);
+  if (!sectionMatch) return content;
+  const afterSection = content.slice(sectionMatch.index);
+  const addoptsPattern = /^([ \t]*addopts\s*=\s*")((?:[^"\\]|\\.)*)(")/m;
+  const addoptsMatch = addoptsPattern.exec(afterSection);
+  if (!addoptsMatch) return content;
+  const prefix = addoptsMatch[1];
+  const currentValue = addoptsMatch[2];
+  const suffix = addoptsMatch[3];
+  const parts = currentValue.split(/\s+/).filter((p) => p.length > 0);
+  const kept = parts.filter((p) => !isExcludedEntry(p));
+  const newIgnores = nodes.map(toPytestIgnore);
+  const updatedValue = [...kept, ...newIgnores].join(" ");
+  const absoluteStart = sectionMatch.index + addoptsMatch.index;
+  const absoluteEnd = absoluteStart + addoptsMatch[0].length;
+  return content.slice(0, absoluteStart) + prefix + updatedValue + suffix + content.slice(absoluteEnd);
+}
+function findTomlArray(content, sectionHeader, key) {
+  const sectionPattern = new RegExp(`^\\[${sectionHeader.replace(/\./g, "\\.")}\\]`, "m");
+  const sectionMatch = sectionPattern.exec(content);
+  if (!sectionMatch) return null;
+  const afterSection = content.slice(sectionMatch.index);
+  const nextSectionMatch = /^\[(?!.*\].*=)/m.exec(afterSection.slice(sectionMatch[0].length));
+  const sectionEnd = nextSectionMatch ? sectionMatch.index + sectionMatch[0].length + nextSectionMatch.index : content.length;
+  const keyPattern = new RegExp(`^([ \\t]*${key}\\s*=\\s*)\\[`, "m");
+  const regionToSearch = content.slice(sectionMatch.index, sectionEnd);
+  const keyMatch = keyPattern.exec(regionToSearch);
+  if (!keyMatch) return null;
+  const arrayStart = sectionMatch.index + keyMatch.index + keyMatch[1].length;
+  let depth = 0;
+  let arrayEnd = arrayStart;
+  for (let i = arrayStart; i < content.length; i++) {
+    if (content[i] === "[") depth++;
+    if (content[i] === "]") {
+      depth--;
+      if (depth === 0) {
+        arrayEnd = i + 1;
+        break;
+      }
+    }
+  }
+  return { arrayStart, arrayEnd };
+}
+function updateTomlArray(content, sectionHeader, key, newEntries) {
+  const info = findTomlArray(content, sectionHeader, key);
+  if (!info) return content;
+  const arrayContent = content.slice(info.arrayStart + 1, info.arrayEnd - 1);
+  const lines = arrayContent.split("\n");
+  const keptLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      keptLines.push(line);
+      continue;
+    }
+    const stringMatch = /"((?:[^"\\]|\\.)*)"/.exec(trimmed);
+    if (stringMatch && isExcludedEntry(stringMatch[1])) {
+      continue;
+    }
+    keptLines.push(line);
+  }
+  const newLines = newEntries.map((entry) => `${ARRAY_INDENT}"${entry}",`);
+  while (keptLines.length > 0 && keptLines[keptLines.length - 1].trim() === "") {
+    keptLines.pop();
+  }
+  const reconstructed = [...keptLines, ...newLines, ""].join("\n");
+  return content.slice(0, info.arrayStart + 1) + reconstructed + content.slice(info.arrayEnd - 1);
+}
+var pythonAdapter = {
+  language: "Python",
+  configFile: PYTHON_CONFIG_FILE,
+  tools: ["pytest", "mypy", "pyright"],
+  excluded: ["ruff (style checked regardless of implementation existence)"],
+  applyExclusions(content, nodes) {
+    let result = content;
+    result = updatePytestAddopts(result, nodes);
+    const mypyEntries = nodes.map(toMypyRegex);
+    result = updateTomlArray(result, MYPY_SECTION, "exclude", mypyEntries);
+    const pyrightEntries = nodes.map(toPyrightPath);
+    result = updateTomlArray(result, PYRIGHT_SECTION, "exclude", pyrightEntries);
+    return {
+      changed: result !== content,
+      content: result
+    };
+  }
+};
+
+// src/spec/apply/exclude/adapters/detect.ts
+var ADAPTERS = [pythonAdapter];
+async function detectLanguage(projectRoot, deps) {
+  for (const adapter of ADAPTERS) {
+    const configPath = join8(projectRoot, adapter.configFile);
+    const exists = await deps.fileExists(configPath);
+    if (exists) {
+      return adapter;
+    }
+  }
+  return null;
+}
+
+// src/spec/apply/exclude/help.ts
+function buildApplyHelp() {
+  const excludePath = `${SPX_PREFIX}${EXCLUDE_FILENAME}`;
+  const languageLines = ADAPTERS.map((adapter) => {
+    const tools = adapter.tools.join(", ");
+    const excluded = adapter.excluded.length > 0 ? `
+      NOT configured: ${adapter.excluded.join(", ")}` : "";
+    return `    ${adapter.language} (${adapter.configFile})
+      Configures: ${tools}${excluded}`;
+  });
+  return `
+Reads ${excludePath} and applies exclusions to the project's tool configuration.
+Each excluded node is translated into the appropriate format for the detected
+language's test runner, type checker, and other quality gate tools.
+
+Source:
+  ${excludePath}
+  One node path per line. Comments (#) and blank lines are ignored.
+  Path traversal (..) and absolute paths are rejected.
+
+Supported languages:
+${languageLines.join("\n\n")}
+
+Detection:
+  The language is auto-detected by checking for config files in order.
+  The first match wins.
+
+Examples:
+  spx spec apply          # Apply exclusions to detected config file
+`;
+}
+var APPLY_HELP = buildApplyHelp();
+
+// src/spec/apply/exclude/exclude-file.ts
+var TOML_UNSAFE_PATTERN = /["\\\n\r\t]/;
+var PATH_TRAVERSAL_PATTERN = /(?:^|\/)\.\.(?:\/|$)/;
+function validateNodePath(path8) {
+  if (path8.startsWith("/")) {
+    return `absolute path rejected: ${path8}`;
+  }
+  if (PATH_TRAVERSAL_PATTERN.test(path8)) {
+    return `path traversal rejected: ${path8}`;
+  }
+  if (TOML_UNSAFE_PATTERN.test(path8)) {
+    return `TOML-unsafe characters rejected: ${path8}`;
+  }
+  return null;
+}
+function readExcludedNodes(content) {
+  return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith(COMMENT_CHAR)).filter((line) => validateNodePath(line) === null);
+}
+
+// src/spec/apply/exclude/command.ts
+import { join as join9 } from "path";
+async function applyExcludeCommand(options) {
+  const { cwd, deps } = options;
+  const excludePath = join9(cwd, SPX_PREFIX, EXCLUDE_FILENAME);
+  const excludeExists = await deps.fileExists(excludePath);
+  if (!excludeExists) {
+    return { exitCode: 1, output: `error: ${excludePath} not found` };
+  }
+  const adapter = await detectLanguage(cwd, deps);
+  if (!adapter) {
+    return { exitCode: 1, output: "error: no supported config file found (checked: pyproject.toml)" };
+  }
+  const configPath = join9(cwd, adapter.configFile);
+  const excludeContent = await deps.readFile(excludePath);
+  const configContent = await deps.readFile(configPath);
+  const nodes = readExcludedNodes(excludeContent);
+  if (nodes.length === 0) {
+    return { exitCode: 0, output: "spx/EXCLUDE is empty \u2014 no excluded nodes to apply." };
+  }
+  const result = adapter.applyExclusions(configContent, nodes);
+  if (result.changed) {
+    await deps.writeFile(configPath, result.content);
+    return {
+      exitCode: 0,
+      output: `Updated ${adapter.configFile} from spx/EXCLUDE (${nodes.length} nodes).`
+    };
+  }
+  return { exitCode: 0, output: `${adapter.configFile} is already in sync with spx/EXCLUDE.` };
+}
+
 // src/domains/spec/index.ts
 function registerSpecCommands(specCmd) {
   specCmd.command("status").description("Get project status").option("--json", "Output as JSON").option("--format <format>", "Output format (text|json|markdown|table)").action(async (options) => {
@@ -2327,6 +2597,25 @@ function registerSpecCommands(specCmd) {
       process.exit(1);
     }
   });
+  specCmd.command("apply").description("Apply spec-tree state to project configuration").addHelpText("after", APPLY_HELP).action(async () => {
+    const result = await applyExcludeCommand({
+      cwd: process.cwd(),
+      deps: {
+        readFile: (path8) => readFile5(path8, "utf-8"),
+        writeFile: (path8, content) => writeFile2(path8, content, "utf-8"),
+        fileExists: async (path8) => {
+          try {
+            await access2(path8);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      }
+    });
+    if (result.output) console.log(result.output);
+    process.exit(result.exitCode);
+  });
 }
 var specDomain = {
   name: "spec",
@@ -3198,7 +3487,7 @@ var ParseErrorCode;
 
 // src/validation/config/scope.ts
 import { existsSync, readdirSync, readFileSync } from "fs";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
@@ -3245,7 +3534,7 @@ function hasTypeScriptFilesRecursive(dirPath, maxDepth = 2, deps = defaultScopeD
     if (hasDirectTsFiles) return true;
     const subdirs = items.filter((item) => item.isDirectory() && !item.name.startsWith("."));
     for (const subdir of subdirs.slice(0, 5)) {
-      if (hasTypeScriptFilesRecursive(join8(dirPath, subdir.name), maxDepth - 1, deps)) {
+      if (hasTypeScriptFilesRecursive(join10(dirPath, subdir.name), maxDepth - 1, deps)) {
         return true;
       }
     }
@@ -3777,7 +4066,7 @@ import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync2, mkdirSync, rmSync, writeFileSync } from "fs";
 import { mkdtemp } from "fs/promises";
 import { tmpdir } from "os";
-import { isAbsolute as isAbsolute2, join as join9 } from "path";
+import { isAbsolute as isAbsolute2, join as join11 } from "path";
 var defaultTypeScriptProcessRunner = { spawn: spawn3 };
 var defaultTypeScriptDeps = {
   mkdtemp,
@@ -3791,19 +4080,19 @@ function buildTypeScriptArgs(context) {
   return scope === VALIDATION_SCOPES.FULL ? ["tsc", "--noEmit"] : ["tsc", "--project", configFile];
 }
 async function createFileSpecificTsconfig(scope, files, deps = defaultTypeScriptDeps) {
-  const tempDir = await deps.mkdtemp(join9(tmpdir(), "validate-ts-"));
-  const configPath = join9(tempDir, "tsconfig.json");
+  const tempDir = await deps.mkdtemp(join11(tmpdir(), "validate-ts-"));
+  const configPath = join11(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope];
   const projectRoot = process.cwd();
-  const absoluteFiles = files.map((file) => isAbsolute2(file) ? file : join9(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute2(file) ? file : join11(projectRoot, file));
   const tempConfig = {
-    extends: join9(projectRoot, baseConfigFile),
+    extends: join11(projectRoot, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
     compilerOptions: {
       noEmit: true,
-      typeRoots: [join9(projectRoot, "node_modules", "@types")],
+      typeRoots: [join11(projectRoot, "node_modules", "@types")],
       types: ["node"]
     }
   };