specatlas 0.1.0

package/dist/chunk-DKFIPJ74.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../core/dist/chunk-5RKNY2ZC.js
+import { promises as fs } from "fs";
+import path from "path";
+async function exists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function readText(p) {
+  return fs.readFile(p, "utf8");
+}
+async function readTextIfExists(p) {
+  try {
+    return await fs.readFile(p, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function writeText(p, content) {
+  await ensureDir(path.dirname(p));
+  await fs.writeFile(p, content, "utf8");
+}
+async function ensureDir(p) {
+  await fs.mkdir(p, { recursive: true });
+}
+async function copyFile(from, to) {
+  await ensureDir(path.dirname(to));
+  await fs.copyFile(from, to);
+}
+async function listDir(p) {
+  try {
+    return await fs.readdir(p);
+  } catch {
+    return [];
+  }
+}
+async function listDirs(p) {
+  const entries = await listDir(p);
+  const out = [];
+  for (const e of entries) {
+    if (await isDirectory(path.join(p, e))) out.push(e);
+  }
+  return out.sort();
+}
+async function walkFiles(root, opts = {}) {
+  const skip = new Set(opts.skipDirs ?? ["node_modules", ".git", "dist", "coverage", ".sdd"]);
+  const out = [];
+  async function rec(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (skip.has(e.name)) continue;
+        await rec(path.join(dir, e.name));
+      } else if (e.isFile()) {
+        out.push({ path: path.join(dir, e.name), name: e.name });
+      }
+    }
+  }
+  await rec(root);
+  return out;
+}
+function toPosix(p) {
+  return p.split(path.sep).join("/");
+}
+
+export {
+  __commonJS,
+  __toESM,
+  exists,
+  isDirectory,
+  readText,
+  readTextIfExists,
+  writeText,
+  ensureDir,
+  copyFile,
+  listDir,
+  listDirs,
+  walkFiles,
+  toPosix
+};

package/dist/chunk-IFALGLUJ.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import {
+  readTextIfExists,
+  toPosix,
+  writeText
+} from "./chunk-DKFIPJ74.js";
+
+// ../core/dist/chunk-2BFXQ65Q.js
+import path from "path";
+import { stringify as stringifyYaml } from "yaml";
+import { createHash } from "crypto";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+function diag(code, severity, message, opts = {}) {
+  const d = { code, severity, message };
+  if (opts.path !== void 0) d.path = opts.path;
+  if (opts.line !== void 0) d.line = opts.line;
+  if (opts.suggestion !== void 0) d.suggestion = opts.suggestion;
+  return d;
+}
+function countBySeverity(diags) {
+  let errors = 0;
+  let warnings = 0;
+  let infos = 0;
+  for (const d of diags) {
+    if (d.severity === "error") errors += 1;
+    else if (d.severity === "warning") warnings += 1;
+    else infos += 1;
+  }
+  return { errors, warnings, infos };
+}
+function canonicalizeMarkdown(md) {
+  let text = md;
+  if (text.charCodeAt(0) === 65279) text = text.slice(1);
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const out = [];
+  let blankRun = 0;
+  for (const line of lines) {
+    const trimmedEnd = line.replace(/[ \t]+$/g, "");
+    if (trimmedEnd.trim() === "") {
+      blankRun += 1;
+      if (blankRun > 1) continue;
+      out.push("");
+    } else {
+      blankRun = 0;
+      out.push(trimmedEnd);
+    }
+  }
+  while (out.length > 0 && out[0] === "") out.shift();
+  while (out.length > 0 && out[out.length - 1] === "") out.pop();
+  return out.join("\n") + "\n";
+}
+function sha256(content) {
+  const h = createHash("sha256");
+  h.update(content);
+  return `sha256:${h.digest("hex")}`;
+}
+function artifactHash(markdown) {
+  return sha256(canonicalizeMarkdown(markdown));
+}
+function shortHash(hash) {
+  return hash.replace(/^sha256:/, "").slice(0, 8);
+}
+var changeMetaSchema = z.object({
+  schema_version: z.number().int().positive().default(1),
+  slug: z.string().min(1),
+  title: z.string().optional(),
+  domain: z.string().optional(),
+  lane: z.enum(["fix", "standard", "full"]).default("standard"),
+  risk: z.enum(["low", "medium", "high"]).optional(),
+  created: z.string().optional(),
+  owner: z.string().optional(),
+  tracker: z.object({ provider: z.string(), id: z.string() }).optional(),
+  paused: z.object({ reason: z.string(), at: z.string(), by: z.string() }).optional(),
+  lane_history: z.array(z.object({ from: z.enum(["fix", "standard", "full"]), to: z.enum(["fix", "standard", "full"]), at: z.string(), by: z.string() })).optional(),
+  diagram_exceptions: z.array(z.string()).optional(),
+  overrides: z.array(z.object({ gate: z.string(), reason: z.string(), by: z.string(), at: z.string() })).optional()
+});
+function parseChangeMeta(raw, filePath) {
+  const diagnostics = [];
+  let data;
+  try {
+    data = parseYaml(raw);
+  } catch (err) {
+    return { diagnostics: [diag("ATLAS-META-001", "error", `meta.yaml inv\xE1lido: ${err.message}`, { path: filePath })] };
+  }
+  const parsed = changeMetaSchema.safeParse(data);
+  if (!parsed.success) {
+    return {
+      diagnostics: parsed.error.issues.map(
+        (issue) => diag("ATLAS-META-002", "error", `meta.yaml (${issue.path.join(".") || "ra\xEDz"}): ${issue.message}`, { path: filePath })
+      )
+    };
+  }
+  const v = parsed.data;
+  const meta = { schemaVersion: v.schema_version, slug: v.slug, lane: v.lane };
+  if (v.title !== void 0) meta.title = v.title;
+  if (v.domain !== void 0) meta.domain = v.domain;
+  if (v.risk !== void 0) meta.risk = v.risk;
+  if (v.created !== void 0) meta.created = v.created;
+  if (v.owner !== void 0) meta.owner = v.owner;
+  if (v.tracker !== void 0) meta.tracker = v.tracker;
+  if (v.paused !== void 0) meta.paused = v.paused;
+  if (v.lane_history !== void 0) meta.laneHistory = v.lane_history;
+  if (v.diagram_exceptions !== void 0) meta.diagramExceptions = v.diagram_exceptions;
+  if (v.overrides !== void 0) meta.overrides = v.overrides;
+  for (const override of meta.overrides ?? []) {
+    if (!override.reason || !override.by) {
+      diagnostics.push(diag("ATLAS-LIFECYCLE-004", "error", `Override del gate "${override.gate}" sin motivo o autor`, { path: filePath }));
+    }
+  }
+  return { meta, diagnostics };
+}
+var approvalsSchema = z.object({
+  schema_version: z.number().int().positive().default(1),
+  approvals: z.array(
+    z.object({
+      artifact: z.string(),
+      artifact_hash: z.string(),
+      approved_by: z.string(),
+      approved_at: z.string(),
+      channel: z.enum(["presentation", "editor", "pr", "tracker", "cli"]).default("cli"),
+      note: z.string().optional()
+    })
+  ).default([])
+});
+function parseApprovals(raw, filePath) {
+  let data;
+  try {
+    data = parseYaml(raw);
+  } catch (err) {
+    return { diagnostics: [diag("ATLAS-APPROVALS-001", "error", `approvals.yaml inv\xE1lido: ${err.message}`, { path: filePath })] };
+  }
+  const parsed = approvalsSchema.safeParse(data);
+  if (!parsed.success) {
+    return {
+      diagnostics: parsed.error.issues.map(
+        (issue) => diag("ATLAS-APPROVALS-002", "error", `approvals.yaml (${issue.path.join(".") || "ra\xEDz"}): ${issue.message}`, { path: filePath })
+      )
+    };
+  }
+  const file = {
+    schemaVersion: parsed.data.schema_version,
+    approvals: parsed.data.approvals.map((a) => {
+      const approval = {
+        artifact: a.artifact,
+        artifactHash: a.artifact_hash,
+        approvedBy: a.approved_by,
+        approvedAt: a.approved_at,
+        channel: a.channel
+      };
+      if (a.note !== void 0) approval.note = a.note;
+      return approval;
+    })
+  };
+  return { approvals: file, diagnostics: [] };
+}
+function normalizeArtifact(sddDir, artifact) {
+  const abs = path.isAbsolute(artifact) ? artifact : path.resolve(sddDir, artifact);
+  const rel = toPosix(path.relative(sddDir, abs));
+  return { rel, abs };
+}
+async function signApproval(opts) {
+  const root = path.resolve(opts.root);
+  const sddDir = path.join(root, ".sdd");
+  const file = path.join(sddDir, "approvals.yaml");
+  const diagnostics = [];
+  const { rel, abs } = normalizeArtifact(sddDir, opts.artifact);
+  if (!opts.by.trim()) {
+    diagnostics.push(diag("ATLAS-APPROVE-001", "error", "La aprobaci\xF3n requiere el nombre de quien aprueba (--by)", { suggestion: 'Ejemplo: satlas approve changes/x/spec.md --by "Mar\xEDa P\xE9rez"`' }));
+    return { file, diagnostics };
+  }
+  const content = await readTextIfExists(abs);
+  if (content === void 0) {
+    diagnostics.push(diag("ATLAS-APPROVE-002", "error", `No existe el artefacto a aprobar: ${rel}`, { path: abs }));
+    return { file, diagnostics };
+  }
+  const existing = await readTextIfExists(file);
+  let approvals = [];
+  if (existing !== void 0) {
+    const parsed = parseApprovals(existing, file);
+    diagnostics.push(...parsed.diagnostics);
+    approvals = parsed.approvals?.approvals ?? [];
+  }
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const approval = {
+    artifact: rel,
+    artifactHash: artifactHash(content),
+    approvedBy: opts.by.trim(),
+    approvedAt: now.toISOString(),
+    channel: opts.channel ?? "cli"
+  };
+  if (opts.note) approval.note = opts.note;
+  approvals = approvals.filter((a) => a.artifact !== rel);
+  approvals.push(approval);
+  const doc = {
+    schema_version: 1,
+    approvals: approvals.map((a) => {
+      const row = {
+        artifact: a.artifact,
+        artifact_hash: a.artifactHash,
+        approved_by: a.approvedBy,
+        approved_at: a.approvedAt,
+        channel: a.channel
+      };
+      if (a.note) row["note"] = a.note;
+      return row;
+    })
+  };
+  if (!opts.dryRun) {
+    await writeText(file, stringifyYaml(doc, { lineWidth: 120 }));
+  }
+  return { approval, file, diagnostics };
+}
+
+export {
+  diag,
+  countBySeverity,
+  sha256,
+  artifactHash,
+  shortHash,
+  parseChangeMeta,
+  parseApprovals,
+  signApproval
+};

package/dist/fsx-VF2P7ALA-XKEWTMDH.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import {
+  copyFile,
+  ensureDir,
+  exists,
+  isDirectory,
+  listDir,
+  listDirs,
+  readText,
+  readTextIfExists,
+  toPosix,
+  walkFiles,
+  writeText
+} from "./chunk-DKFIPJ74.js";
+export {
+  copyFile,
+  ensureDir,
+  exists,
+  isDirectory,
+  listDir,
+  listDirs,
+  readText,
+  readTextIfExists,
+  toPosix,
+  walkFiles,
+  writeText
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "specatlas",
+  "version": "0.1.0",
+  "description": "SpecAtlas: kernel determinista de Spec-Driven Development (CLI)",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "specatlas": "dist/bin.js",
+    "satlas": "dist/bin.js"
+  },
+  "main": "dist/bin.js",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "sdd",
+    "spec-driven-development",
+    "specs",
+    "agents",
+    "cli",
+    "traceability"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AlonsoAM/specatlas.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/AlonsoAM/specatlas",
+  "bugs": {
+    "url": "https://github.com/AlonsoAM/specatlas/issues"
+  },
+  "dependencies": {
+    "yaml": "^2.6.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@specatlas/adapters": "0.1.0",
+    "@specatlas/core": "0.1.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsup"
+  }
+}