@elmundi/ship-cli 0.8.1 → 0.11.2

package/lib/adapters/language/rust.mjs

@@ -0,0 +1,23 @@
+import { isFile } from "../_fs.mjs";
+
+export const id = "rust";
+export const kind = "language";
+
+export async function detect(cwd) {
+  if (isFile(cwd, "Cargo.toml")) {
+    return {
+      present: true,
+      confidence: 1,
+      evidence: [{ type: "file", where: "Cargo.toml", match: "present" }],
+    };
+  }
+  return { present: false, confidence: 0, evidence: [] };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/language/swift.mjs

@@ -0,0 +1,37 @@
+import { isFile, listDir, readText } from "../_fs.mjs";
+
+export const id = "swift";
+export const kind = "language";
+
+export async function detect(cwd) {
+  const evidence = [];
+
+  if (isFile(cwd, "Package.swift")) {
+    evidence.push({ type: "file", where: "Package.swift", match: "present" });
+  }
+
+  for (const name of listDir(cwd, ".")) {
+    if (name.endsWith(".xcodeproj")) {
+      evidence.push({ type: "dir", where: name, match: "xcodeproj" });
+      break;
+    }
+  }
+
+  if (isFile(cwd, "Podfile")) {
+    const body = readText(cwd, "Podfile") || "";
+    if (/\bswift\b/i.test(body) || /:swift/i.test(body)) {
+      evidence.push({ type: "file", where: "Podfile", match: "swift pods" });
+    }
+  }
+
+  if (!evidence.length) return { present: false, confidence: 0, evidence };
+  return { present: true, confidence: 1, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/language/ts.mjs

@@ -0,0 +1,35 @@
+import { isFile, pkgDeps, readJson } from "../_fs.mjs";
+
+export const id = "ts";
+export const kind = "language";
+
+export async function detect(cwd) {
+  const evidence = [];
+  let hit = false;
+
+  if (isFile(cwd, "tsconfig.json")) {
+    hit = true;
+    evidence.push({ type: "file", where: "tsconfig.json", match: "present" });
+  }
+
+  const pkg = readJson(cwd, "package.json");
+  const deps = pkgDeps(pkg);
+  if (deps.typescript) {
+    hit = true;
+    evidence.push({
+      type: "package",
+      where: "package.json",
+      match: `typescript@${deps.typescript}`,
+    });
+  }
+
+  return { present: hit, confidence: hit ? 1 : 0, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/trackers/azure-boards.mjs

@@ -0,0 +1,49 @@
+import { exists, readEnvFiles, readGithubWorkflows } from "../_fs.mjs";
+
+export const id = "azure-boards";
+export const kind = "tracker";
+
+const ENV_KEYS = /\b(AZURE_DEVOPS_PAT|AZURE_DEVOPS_ORG|AZURE_DEVOPS_EXT_PAT)\b/;
+
+export async function detect(cwd) {
+  const evidence = [];
+  let envHit = false;
+  let ciHit = false;
+
+  for (const { file, content } of readEnvFiles(cwd)) {
+    const m = content.match(ENV_KEYS);
+    if (m) {
+      envHit = true;
+      evidence.push({ type: "env", where: file, match: m[1] });
+    }
+  }
+
+  if (exists(cwd, ".vsts-ci.yml")) {
+    ciHit = true;
+    evidence.push({ type: "file", where: ".vsts-ci.yml", match: "present" });
+  }
+
+  for (const { file, content } of readGithubWorkflows(cwd)) {
+    if (/azure[-_ ]?boards/i.test(content) || /dev\.azure\.com/i.test(content)) {
+      ciHit = true;
+      evidence.push({ type: "workflow", where: file, match: "azure-boards reference" });
+    }
+  }
+
+  const present = envHit || ciHit;
+  let confidence = 0;
+  if (present) {
+    confidence = 0.7;
+    if (envHit && ciHit) confidence = 0.95;
+  }
+
+  return { present, confidence, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/trackers/clickup.mjs

@@ -0,0 +1,43 @@
+import { pkgDeps, readEnvFiles, readJson } from "../_fs.mjs";
+
+export const id = "clickup";
+export const kind = "tracker";
+
+export async function detect(cwd) {
+  const evidence = [];
+  let envHit = false;
+  let packageHit = false;
+
+  for (const { file, content } of readEnvFiles(cwd)) {
+    if (/\bCLICKUP_API_TOKEN\b/.test(content)) {
+      envHit = true;
+      evidence.push({ type: "env", where: file, match: "CLICKUP_API_TOKEN" });
+    }
+  }
+
+  const pkg = readJson(cwd, "package.json");
+  const deps = pkgDeps(pkg);
+  for (const name of Object.keys(deps)) {
+    if (name.startsWith("@clickup/")) {
+      packageHit = true;
+      evidence.push({ type: "package", where: "package.json", match: name });
+    }
+  }
+
+  const present = envHit || packageHit;
+  let confidence = 0;
+  if (present) {
+    confidence = 0.7;
+    if (envHit && packageHit) confidence = 0.95;
+  }
+
+  return { present, confidence, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/trackers/github-issues.mjs

@@ -0,0 +1,52 @@
+import { isDir, listDir, readEnvFiles, readGithubWorkflows } from "../_fs.mjs";
+
+export const id = "github-issues";
+export const kind = "tracker";
+
+export async function detect(cwd) {
+  const evidence = [];
+  let templateHit = false;
+  let tokenHit = false;
+
+  if (isDir(cwd, ".github", "ISSUE_TEMPLATE")) {
+    const entries = listDir(cwd, ".github/ISSUE_TEMPLATE").filter((n) => !n.startsWith("."));
+    templateHit = true;
+    evidence.push({
+      type: "dir",
+      where: ".github/ISSUE_TEMPLATE/",
+      match: `${entries.length} template(s)`,
+    });
+  }
+
+  for (const { file, content } of readEnvFiles(cwd)) {
+    if (/\bGITHUB_TOKEN\b/.test(content)) {
+      tokenHit = true;
+      evidence.push({ type: "env", where: file, match: "GITHUB_TOKEN" });
+      break;
+    }
+  }
+  if (!tokenHit) {
+    for (const { file, content } of readGithubWorkflows(cwd)) {
+      if (/\bGITHUB_TOKEN\b/.test(content)) {
+        tokenHit = true;
+        evidence.push({ type: "workflow", where: file, match: "GITHUB_TOKEN" });
+        break;
+      }
+    }
+  }
+
+  const present = templateHit || tokenHit;
+  let confidence = 0;
+  if (templateHit) confidence = 0.8;
+  else if (tokenHit) confidence = 0.3;
+
+  return { present, confidence, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/trackers/jira.mjs

@@ -0,0 +1,72 @@
+import {
+  exists,
+  readEnvFiles,
+  readGithubWorkflows,
+  readJson,
+} from "../_fs.mjs";
+
+export const id = "jira";
+export const kind = "tracker";
+
+const ENV_KEYS = /\b(JIRA_URL|JIRA_API_TOKEN|ATLASSIAN_TOKEN|ATLASSIAN_API_TOKEN)\b/;
+
+export async function detect(cwd) {
+  const evidence = [];
+  let envHit = false;
+  let workflowHit = false;
+  let fileHit = false;
+
+  for (const { file, content } of readEnvFiles(cwd)) {
+    const m = content.match(ENV_KEYS);
+    if (m) {
+      envHit = true;
+      evidence.push({ type: "env", where: file, match: m[1] });
+    }
+  }
+
+  for (const { file, content } of readGithubWorkflows(cwd)) {
+    if (/\bjira\b/i.test(content) || /atlassian/i.test(content)) {
+      workflowHit = true;
+      evidence.push({ type: "workflow", where: file, match: "jira/atlassian reference" });
+    }
+  }
+
+  if (exists(cwd, ".jira")) {
+    fileHit = true;
+    evidence.push({ type: "dir", where: ".jira/", match: "present" });
+  }
+  if (exists(cwd, "atlassian-connect.json")) {
+    fileHit = true;
+    evidence.push({ type: "file", where: "atlassian-connect.json", match: "present" });
+  }
+
+  const pkg = readJson(cwd, "package.json");
+  const scripts = pkg && typeof pkg === "object" ? pkg.scripts : null;
+  if (scripts && typeof scripts === "object") {
+    for (const [k, v] of Object.entries(scripts)) {
+      if (typeof v === "string" && /\bjira\b/i.test(v)) {
+        workflowHit = true;
+        evidence.push({ type: "script", where: `package.json:scripts.${k}`, match: "jira reference" });
+        break;
+      }
+    }
+  }
+
+  const present = envHit || workflowHit || fileHit;
+  let confidence = 0;
+  if (present) {
+    confidence = 0.7;
+    if (envHit && (workflowHit || fileHit)) confidence = 0.95;
+    if (fileHit && workflowHit) confidence = Math.max(confidence, 0.85);
+  }
+
+  return { present, confidence, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/trackers/linear.mjs

@@ -0,0 +1,62 @@
+import {
+  exists,
+  pkgDeps,
+  readEnvFiles,
+  readGithubWorkflows,
+  readJson,
+} from "../_fs.mjs";
+
+export const id = "linear";
+export const kind = "tracker";
+
+export async function detect(cwd) {
+  const evidence = [];
+  let envHit = false;
+  let workflowHit = false;
+  let packageHit = false;
+
+  for (const { file, content } of readEnvFiles(cwd)) {
+    if (/\bLINEAR_API_KEY\b/.test(content)) {
+      envHit = true;
+      evidence.push({ type: "env", where: file, match: "LINEAR_API_KEY" });
+    }
+  }
+
+  const pkg = readJson(cwd, "package.json");
+  const deps = pkgDeps(pkg);
+  for (const name of Object.keys(deps)) {
+    if (name.startsWith("@linear/")) {
+      packageHit = true;
+      evidence.push({ type: "package", where: "package.json", match: name });
+    }
+  }
+
+  for (const { file, content } of readGithubWorkflows(cwd)) {
+    if (/\blinear\b/i.test(content)) {
+      workflowHit = true;
+      evidence.push({ type: "workflow", where: file, match: "linear reference" });
+    }
+  }
+
+  if (exists(cwd, ".linear")) {
+    packageHit = true;
+    evidence.push({ type: "dir", where: ".linear/", match: "present" });
+  }
+
+  const present = envHit || workflowHit || packageHit;
+  let confidence = 0;
+  if (present) {
+    confidence = 0.7;
+    if (envHit && (workflowHit || packageHit)) confidence = 0.95;
+  }
+
+  return { present, confidence, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/trackers/none.mjs

@@ -0,0 +1,18 @@
+export const id = "none";
+export const kind = "tracker";
+
+export async function detect() {
+  return {
+    present: true,
+    confidence: 0.05,
+    evidence: [{ type: "fallback", where: "-", match: "no tracker detected" }],
+  };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/trackers/spreadsheet.mjs

@@ -0,0 +1,28 @@
+import { exists } from "../_fs.mjs";
+
+export const id = "spreadsheet";
+export const kind = "tracker";
+
+export async function detect(cwd) {
+  const evidence = [];
+  let hit = false;
+
+  if (exists(cwd, ".ship", "tracker-sheet.csv")) {
+    hit = true;
+    evidence.push({ type: "file", where: ".ship/tracker-sheet.csv", match: "present" });
+  }
+  if (exists(cwd, "tracker.xlsx")) {
+    hit = true;
+    evidence.push({ type: "file", where: "tracker.xlsx", match: "present" });
+  }
+
+  return { present: hit, confidence: hit ? 0.9 : 0, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/artifacts/fs-index.mjs

@@ -0,0 +1,230 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Shared filesystem index for v2 artifact trees: walks
+ * `<repoRoot>/artifacts/<plural>/<id>/ARTIFACT.md` and parses just enough YAML
+ * front-matter to reconstruct the same entry shape we used to read out of the
+ * legacy `<plural>/manifest.json` files.
+ *
+ * Zero dependencies — only node builtins. Anything we cannot parse falls
+ * through (the entry still gets emitted with whatever fields we recovered).
+ */
+
+const KIND_TO_PLURAL = {
+  pattern: "patterns",
+  tool: "tools",
+  collection: "collections",
+};
+
+/**
+ * @param {"pattern"|"tool"|"collection"} kind
+ */
+export function pluralFor(kind) {
+  return KIND_TO_PLURAL[kind] || `${kind}s`;
+}
+
+/**
+ * Walk `artifacts/<plural>/*` and return the parsed entries (same shape as the
+ * legacy manifest).
+ *
+ * @param {string} repoRoot
+ * @param {"pattern"|"tool"|"collection"} kind
+ * @returns {Array<Record<string, any>>}
+ */
+export function scanArtifacts(repoRoot, kind) {
+  const plural = pluralFor(kind);
+  const dir = path.join(repoRoot, "artifacts", plural);
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return [];
+
+  const ids = fs.readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .sort();
+
+  /** @type {Array<Record<string, any>>} */
+  const out = [];
+  for (const id of ids) {
+    const file = path.join(dir, id, "ARTIFACT.md");
+    if (!fs.existsSync(file)) continue;
+    let raw;
+    try {
+      raw = fs.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const { fm } = parseFrontMatter(raw);
+    const entry = entryFromFrontmatter(fm, kind, id);
+    out.push(entry);
+  }
+  return out;
+}
+
+/**
+ * Read the full ARTIFACT.md (frontmatter + body) for a specific id. Returns
+ * null when the file is absent so callers can emit the same "Unknown id"
+ * messages they did before.
+ *
+ * @param {string} repoRoot
+ * @param {"pattern"|"tool"|"collection"} kind
+ * @param {string} id
+ */
+export function readArtifactFile(repoRoot, kind, id) {
+  const plural = pluralFor(kind);
+  const file = path.join(repoRoot, "artifacts", plural, id, "ARTIFACT.md");
+  if (!fs.existsSync(file) || !fs.statSync(file).isFile()) return null;
+  return { absPath: file, content: fs.readFileSync(file, "utf8") };
+}
+
+function entryFromFrontmatter(fm, kind, id) {
+  const plural = pluralFor(kind);
+  const description = typeof fm.description === "string" ? fm.description : "";
+  const summary = description ? firstSentence(description) : "";
+  return {
+    id: typeof fm.id === "string" && fm.id ? fm.id : id,
+    title: typeof fm.name === "string" ? fm.name : id,
+    summary,
+    path: `artifacts/${plural}/${id}/ARTIFACT.md`,
+    tags: Array.isArray(fm.tags) ? fm.tags : [],
+    group: typeof fm.group === "string" ? fm.group : null,
+    version: typeof fm.version === "string" ? fm.version : null,
+    content_sha256: typeof fm.content_sha256 === "string" ? fm.content_sha256 : null,
+    updated_at: typeof fm.updated_at === "string" ? fm.updated_at : null,
+    channel: typeof fm.channel === "string" ? fm.channel : null,
+    min_shipctl: typeof fm.min_shipctl === "string" ? fm.min_shipctl : null,
+    deprecated: fm.deprecated === true || fm.deprecated === "true",
+    replaced_by: fm.replaced_by ?? null,
+    yanked: fm.yanked === true || fm.yanked === "true",
+  };
+}
+
+function firstSentence(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  const m = /[.!?](\s|$)/.exec(trimmed);
+  if (!m) return trimmed;
+  return trimmed.slice(0, m.index + 1).trim();
+}
+
+/**
+ * Tiny YAML front-matter parser tailored for v2 ARTIFACT.md files.
+ *
+ * Supports:
+ *   - simple `key: value`
+ *   - inline lists `key: [a, b]`
+ *   - folded scalars `key: >` / `key: >-` with indented continuation lines
+ *   - quoted strings (single or double)
+ *   - one level of nested mapping (used by `spec:`)
+ *   - comments (`# …`)
+ *
+ * Anything else is best-effort: the value is captured as the trimmed string.
+ *
+ * @param {string} source
+ * @returns {{fm: Record<string, any>, body: string}}
+ */
+export function parseFrontMatter(source) {
+  if (typeof source !== "string") return { fm: {}, body: "" };
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(source);
+  if (!match) return { fm: {}, body: source };
+  const block = match[1];
+  const body = source.slice(match[0].length);
+  /** @type {Record<string, any>} */
+  const fm = {};
+  const lines = block.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const rawLine = lines[i];
+    const line = rawLine.replace(/\s+$/, "");
+    if (!line || /^\s*#/.test(line)) {
+      i += 1;
+      continue;
+    }
+    const top = /^([A-Za-z_][A-Za-z0-9_.-]*)\s*:\s*(.*)$/.exec(line);
+    if (!top) {
+      i += 1;
+      continue;
+    }
+    const key = top[1];
+    const value = top[2];
+
+    if (value === ">" || value === ">-") {
+      const folded = [];
+      i += 1;
+      while (i < lines.length) {
+        const cont = lines[i];
+        if (cont === "" || cont === "\r") {
+          // Preserve paragraph breaks as a single space in folded scalars.
+          folded.push("");
+          i += 1;
+          continue;
+        }
+        const m = /^(\s+)(.*)$/.exec(cont);
+        if (!m) break;
+        folded.push(m[2]);
+        i += 1;
+      }
+      let joined = folded.join(" ").replace(/\s+/g, " ").trim();
+      if (value === ">-") joined = joined.replace(/\s+$/, "");
+      fm[key] = joined;
+      continue;
+    }
+
+    if (/^\[.*\]$/.test(value.trim())) {
+      const inner = value.trim().slice(1, -1).trim();
+      fm[key] = inner.length ? inner.split(/\s*,\s*/).map(unquote) : [];
+      i += 1;
+      continue;
+    }
+
+    if (value === "") {
+      // Possible nested mapping or empty scalar. Peek ahead.
+      const child = {};
+      let saw = false;
+      let j = i + 1;
+      while (j < lines.length) {
+        const cont = lines[j];
+        if (!cont.trim()) { j += 1; continue; }
+        const indented = /^(\s{2,})([A-Za-z_][A-Za-z0-9_.-]*)\s*:\s*(.*)$/.exec(cont);
+        if (!indented) break;
+        const [, , subKey, subVal] = indented;
+        if (/^\[.*\]$/.test(subVal.trim())) {
+          const inner = subVal.trim().slice(1, -1).trim();
+          child[subKey] = inner.length ? inner.split(/\s*,\s*/).map(unquote) : [];
+        } else {
+          child[subKey] = coerceScalar(subVal);
+        }
+        saw = true;
+        j += 1;
+      }
+      if (saw) {
+        fm[key] = child;
+        i = j;
+        continue;
+      }
+      fm[key] = "";
+      i += 1;
+      continue;
+    }
+
+    fm[key] = coerceScalar(value);
+    i += 1;
+  }
+  return { fm, body };
+}
+
+function unquote(value) {
+  if (typeof value !== "string") return value;
+  const v = value.trim();
+  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+    return v.slice(1, -1);
+  }
+  return v;
+}
+
+function coerceScalar(rawValue) {
+  const v = unquote(String(rawValue).trim());
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v === "null" || v === "~") return null;
+  return v;
+}