@specatlas/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SpecAtlas contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/approvals-HCBC7QDM.js

@@ -0,0 +1,7 @@
+import {
+  signApproval
+} from "./chunk-2BFXQ65Q.js";
+import "./chunk-5RKNY2ZC.js";
+export {
+  signApproval
+};

package/dist/chunk-2BFXQ65Q.js

@@ -0,0 +1,239 @@
+import {
+  readTextIfExists,
+  toPosix,
+  writeText
+} from "./chunk-5RKNY2ZC.js";
+
+// src/approvals.ts
+import path from "path";
+import { stringify as stringifyYaml } from "yaml";
+
+// src/diagnostics.ts
+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 hasErrors(diags) {
+  return diags.some((d) => d.severity === "error");
+}
+
+// src/hash.ts
+import { createHash } from "crypto";
+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);
+}
+
+// src/parse/meta.ts
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+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: [] };
+}
+
+// src/approvals.ts
+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,
+  hasErrors,
+  canonicalizeMarkdown,
+  sha256,
+  artifactHash,
+  shortHash,
+  changeMetaSchema,
+  parseChangeMeta,
+  approvalsSchema,
+  parseApprovals,
+  signApproval
+};

package/dist/chunk-5RKNY2ZC.js

@@ -0,0 +1,94 @@
+// src/fsx.ts
+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 {
+  exists,
+  isDirectory,
+  readText,
+  readTextIfExists,
+  writeText,
+  ensureDir,
+  copyFile,
+  listDir,
+  listDirs,
+  walkFiles,
+  toPosix
+};

package/dist/fsx-VF2P7ALA.js

@@ -0,0 +1,26 @@
+import {
+  copyFile,
+  ensureDir,
+  exists,
+  isDirectory,
+  listDir,
+  listDirs,
+  readText,
+  readTextIfExists,
+  toPosix,
+  walkFiles,
+  writeText
+} from "./chunk-5RKNY2ZC.js";
+export {
+  copyFile,
+  ensureDir,
+  exists,
+  isDirectory,
+  listDir,
+  listDirs,
+  readText,
+  readTextIfExists,
+  toPosix,
+  walkFiles,
+  writeText
+};