@elmundi/ship-cli 0.8.1 → 0.11.2

package/lib/adapters/_fs.mjs

@@ -0,0 +1,165 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Shared filesystem helpers for adapter `detect()` hooks.
+ *
+ * All helpers are synchronous (detect() is still exposed as async so future
+ * adapters that need I/O concurrency can use it freely) and **never throw** on
+ * missing files — adapters must return `present:false` instead of propagating
+ * ENOENT up to the doctor command.
+ */
+
+export function exists(cwd, ...rel) {
+  try {
+    return fs.existsSync(path.join(cwd, ...rel));
+  } catch {
+    return false;
+  }
+}
+
+export function isFile(cwd, ...rel) {
+  try {
+    const s = fs.statSync(path.join(cwd, ...rel));
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+
+export function isDir(cwd, ...rel) {
+  try {
+    const s = fs.statSync(path.join(cwd, ...rel));
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function readText(cwd, rel) {
+  try {
+    return fs.readFileSync(path.join(cwd, rel), "utf8");
+  } catch {
+    return null;
+  }
+}
+
+export function readJson(cwd, rel) {
+  const txt = readText(cwd, rel);
+  if (txt == null) return null;
+  try {
+    return JSON.parse(txt);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * List direct children of `cwd/rel`. Returns [] if missing / not a directory.
+ */
+export function listDir(cwd, rel) {
+  try {
+    return fs.readdirSync(path.join(cwd, rel));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Shallow recursive walk capped at depth and file count to avoid hammering
+ * huge monorepos during `shipctl doctor`.
+ */
+export function walk(cwd, { maxDepth = 3, maxFiles = 500, ignore = DEFAULT_IGNORE } = {}) {
+  const out = [];
+  const base = path.resolve(cwd);
+  function visit(dir, depth) {
+    if (out.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (out.length >= maxFiles) return;
+      if (ignore.has(e.name)) continue;
+      const full = path.join(dir, e.name);
+      const rel = path.relative(base, full);
+      if (e.isDirectory()) {
+        if (depth < maxDepth) visit(full, depth + 1);
+      } else if (e.isFile()) {
+        out.push(rel);
+      }
+    }
+  }
+  visit(base, 0);
+  return out;
+}
+
+export const DEFAULT_IGNORE = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  ".turbo",
+  "target",
+  "venv",
+  ".venv",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".gradle",
+  "Pods",
+  "DerivedData",
+]);
+
+/**
+ * Read every .env*-style file at the repo root. Returns an array of
+ * `{file, content}`. Hidden/ignored by .gitignore is not a concern — we are
+ * only scanning for variable *names*, never values.
+ */
+export function readEnvFiles(cwd) {
+  const hits = [];
+  const entries = listDir(cwd, ".");
+  for (const name of entries) {
+    if (!/^\.env($|[.\-])/.test(name)) continue;
+    if (!isFile(cwd, name)) continue;
+    const content = readText(cwd, name);
+    if (content != null) hits.push({ file: name, content });
+  }
+  return hits;
+}
+
+/**
+ * Read every YAML workflow under `.github/workflows/`. Returns
+ * `[{file, content}]`.
+ */
+export function readGithubWorkflows(cwd) {
+  const dir = path.join(".github", "workflows");
+  if (!isDir(cwd, dir)) return [];
+  const hits = [];
+  for (const name of listDir(cwd, dir)) {
+    if (!/\.ya?ml$/i.test(name)) continue;
+    const rel = path.join(dir, name);
+    const content = readText(cwd, rel);
+    if (content != null) hits.push({ file: rel, content });
+  }
+  return hits;
+}
+
+/**
+ * Flatten a package.json's dependency sections into a single `{name → range}`
+ * map for easier inspection.
+ */
+export function pkgDeps(pkg) {
+  if (!pkg || typeof pkg !== "object") return {};
+  const all = {};
+  for (const key of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+    const obj = pkg[key];
+    if (obj && typeof obj === "object") Object.assign(all, obj);
+  }
+  return all;
+}

package/lib/adapters/agents/index.mjs

@@ -0,0 +1,26 @@
+/**
+ * Agent detection today lives in `cli/lib/detect.mjs` (synchronous, returns
+ * the `AgentTarget[]` shape with `{id, label, paths, confidence}`).
+ *
+ * This module re-exports it and provides a thin adapter-shaped wrapper
+ * (`detectAll`) that yields `{id, present, confidence, evidence}` entries
+ * consistent with tracker/ci/language adapters. Full per-agent adapter
+ * wrappers (bootstrap/verify) land in a later task.
+ */
+import { detectAgentTargets, KNOWN_AGENTS } from "../../detect.mjs";
+
+export { detectAgentTargets, KNOWN_AGENTS };
+
+/**
+ * @param {string} cwd
+ * @returns {Promise<Array<{id:string, present:boolean, confidence:number, evidence:Array}>>}
+ */
+export async function detectAllAgents(cwd) {
+  const targets = detectAgentTargets(cwd);
+  return targets.map((t) => ({
+    id: t.id,
+    present: true,
+    confidence: t.confidence,
+    evidence: [{ type: "file", where: t.paths[0] || "-", match: t.label }],
+  }));
+}

package/lib/adapters/ci/azure-pipelines.mjs

@@ -0,0 +1,23 @@
+import { isFile } from "../_fs.mjs";
+
+export const id = "azure-pipelines";
+export const kind = "ci";
+
+export async function detect(cwd) {
+  if (isFile(cwd, "azure-pipelines.yml") || isFile(cwd, "azure-pipelines.yaml")) {
+    return {
+      present: true,
+      confidence: 1,
+      evidence: [{ type: "file", where: "azure-pipelines.yml", 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/ci/buildkite.mjs

@@ -0,0 +1,24 @@
+import { isDir, listDir } from "../_fs.mjs";
+
+export const id = "buildkite";
+export const kind = "ci";
+
+export async function detect(cwd) {
+  if (!isDir(cwd, ".buildkite")) {
+    return { present: false, confidence: 0, evidence: [] };
+  }
+  const files = listDir(cwd, ".buildkite");
+  return {
+    present: true,
+    confidence: 1,
+    evidence: [{ type: "dir", where: ".buildkite/", match: `${files.length} entry(ies)` }],
+  };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/ci/circleci.mjs

@@ -0,0 +1,23 @@
+import { isFile } from "../_fs.mjs";
+
+export const id = "circleci";
+export const kind = "ci";
+
+export async function detect(cwd) {
+  if (isFile(cwd, ".circleci", "config.yml") || isFile(cwd, ".circleci", "config.yaml")) {
+    return {
+      present: true,
+      confidence: 1,
+      evidence: [{ type: "file", where: ".circleci/config.yml", 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/ci/gh-actions.mjs

@@ -0,0 +1,29 @@
+import { isDir, listDir } from "../_fs.mjs";
+
+export const id = "gh-actions";
+export const kind = "ci";
+
+export async function detect(cwd) {
+  const evidence = [];
+  if (!isDir(cwd, ".github", "workflows")) {
+    return { present: false, confidence: 0, evidence };
+  }
+  const files = listDir(cwd, ".github/workflows").filter((f) => /\.ya?ml$/i.test(f));
+  if (files.length === 0) {
+    return { present: false, confidence: 0, evidence };
+  }
+  evidence.push({
+    type: "dir",
+    where: ".github/workflows/",
+    match: `${files.length} workflow(s)`,
+  });
+  return { present: true, confidence: 1, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/ci/gitlab-ci.mjs

@@ -0,0 +1,23 @@
+import { isFile } from "../_fs.mjs";
+
+export const id = "gitlab-ci";
+export const kind = "ci";
+
+export async function detect(cwd) {
+  if (isFile(cwd, ".gitlab-ci.yml")) {
+    return {
+      present: true,
+      confidence: 1,
+      evidence: [{ type: "file", where: ".gitlab-ci.yml", 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/ci/jenkins.mjs

@@ -0,0 +1,23 @@
+import { isFile } from "../_fs.mjs";
+
+export const id = "jenkins";
+export const kind = "ci";
+
+export async function detect(cwd) {
+  if (isFile(cwd, "Jenkinsfile")) {
+    return {
+      present: true,
+      confidence: 1,
+      evidence: [{ type: "file", where: "Jenkinsfile", 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/ci/manual.mjs

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

package/lib/adapters/index.mjs

@@ -0,0 +1,122 @@
+import * as linear from "./trackers/linear.mjs";
+import * as jira from "./trackers/jira.mjs";
+import * as githubIssues from "./trackers/github-issues.mjs";
+import * as azureBoards from "./trackers/azure-boards.mjs";
+import * as clickup from "./trackers/clickup.mjs";
+import * as spreadsheet from "./trackers/spreadsheet.mjs";
+import * as trackerNone from "./trackers/none.mjs";
+
+import * as ghActions from "./ci/gh-actions.mjs";
+import * as gitlabCi from "./ci/gitlab-ci.mjs";
+import * as buildkite from "./ci/buildkite.mjs";
+import * as circleci from "./ci/circleci.mjs";
+import * as azurePipelines from "./ci/azure-pipelines.mjs";
+import * as jenkins from "./ci/jenkins.mjs";
+import * as ciManual from "./ci/manual.mjs";
+
+import * as ts from "./language/ts.mjs";
+import * as js from "./language/js.mjs";
+import * as py from "./language/py.mjs";
+import * as go from "./language/go.mjs";
+import * as rust from "./language/rust.mjs";
+import * as java from "./language/java.mjs";
+import * as kotlin from "./language/kotlin.mjs";
+import * as swift from "./language/swift.mjs";
+import * as dart from "./language/dart.mjs";
+
+import { detectAllAgents } from "./agents/index.mjs";
+
+/** @typedef {{id:string, kind:string, detect:(cwd:string)=>Promise<{present:boolean,confidence:number,evidence:Array}>}} Adapter */
+
+export const trackers = Object.freeze({
+  linear,
+  jira,
+  "github-issues": githubIssues,
+  "azure-boards": azureBoards,
+  clickup,
+  spreadsheet,
+  none: trackerNone,
+});
+
+export const ci = Object.freeze({
+  "gh-actions": ghActions,
+  "gitlab-ci": gitlabCi,
+  buildkite,
+  circleci,
+  "azure-pipelines": azurePipelines,
+  jenkins,
+  manual: ciManual,
+});
+
+export const language = Object.freeze({
+  ts,
+  js,
+  py,
+  go,
+  rust,
+  java,
+  kotlin,
+  swift,
+  dart,
+});
+
+export { detectAllAgents };
+
+function sortByConfidenceDesc(entries) {
+  return [...entries].sort((a, b) => b.confidence - a.confidence || a.id.localeCompare(b.id));
+}
+
+/**
+ * Run every adapter in every category against `cwd`, concurrently per
+ * category, and return findings sorted by confidence descending.
+ *
+ * @param {string} cwd
+ * @returns {Promise<{trackers:Array, ci:Array, language:Array, agents:Array}>}
+ */
+export async function detectAll(cwd) {
+  const runOne = async (registry) => {
+    const ids = Object.keys(registry);
+    const entries = await Promise.all(
+      ids.map(async (id) => {
+        const adapter = registry[id];
+        try {
+          const r = await adapter.detect(cwd);
+          return {
+            id,
+            present: !!r.present,
+            confidence: typeof r.confidence === "number" ? r.confidence : 0,
+            evidence: Array.isArray(r.evidence) ? r.evidence : [],
+          };
+        } catch (e) {
+          return {
+            id,
+            present: false,
+            confidence: 0,
+            evidence: [
+              {
+                type: "error",
+                where: "-",
+                match: String(e && e.message ? e.message : e),
+              },
+            ],
+          };
+        }
+      }),
+    );
+    return sortByConfidenceDesc(entries);
+  };
+
+  const [trackerResults, ciResults, languageResults, agentResults] = await Promise.all([
+    runOne(trackers),
+    runOne(ci),
+    runOne(language),
+    detectAllAgents(cwd),
+  ]);
+
+  return {
+    trackers: trackerResults,
+    ci: ciResults,
+    language: languageResults,
+    agents: sortByConfidenceDesc(agentResults),
+  };
+}

package/lib/adapters/language/dart.mjs

@@ -0,0 +1,23 @@
+import { isFile } from "../_fs.mjs";
+
+export const id = "dart";
+export const kind = "language";
+
+export async function detect(cwd) {
+  if (isFile(cwd, "pubspec.yaml")) {
+    return {
+      present: true,
+      confidence: 1,
+      evidence: [{ type: "file", where: "pubspec.yaml", 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/go.mjs

@@ -0,0 +1,23 @@
+import { isFile } from "../_fs.mjs";
+
+export const id = "go";
+export const kind = "language";
+
+export async function detect(cwd) {
+  if (isFile(cwd, "go.mod")) {
+    return {
+      present: true,
+      confidence: 1,
+      evidence: [{ type: "file", where: "go.mod", 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/java.mjs

@@ -0,0 +1,27 @@
+import { isFile } from "../_fs.mjs";
+
+export const id = "java";
+export const kind = "language";
+
+export async function detect(cwd) {
+  const evidence = [];
+  if (isFile(cwd, "pom.xml")) {
+    evidence.push({ type: "file", where: "pom.xml", match: "present" });
+  }
+  if (isFile(cwd, "build.gradle")) {
+    evidence.push({ type: "file", where: "build.gradle", match: "present" });
+  }
+  if (isFile(cwd, "build.gradle.kts")) {
+    evidence.push({ type: "file", where: "build.gradle.kts", match: "present" });
+  }
+  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/js.mjs

@@ -0,0 +1,32 @@
+import { isFile, pkgDeps, readJson } from "../_fs.mjs";
+
+export const id = "js";
+export const kind = "language";
+
+export async function detect(cwd) {
+  if (!isFile(cwd, "package.json")) {
+    return { present: false, confidence: 0, evidence: [] };
+  }
+  const pkg = readJson(cwd, "package.json");
+  const deps = pkgDeps(pkg);
+  if (deps.typescript || isFile(cwd, "tsconfig.json")) {
+    return {
+      present: false,
+      confidence: 0,
+      evidence: [{ type: "file", where: "package.json", match: "typescript present → js skipped" }],
+    };
+  }
+  return {
+    present: true,
+    confidence: 0.9,
+    evidence: [{ type: "file", where: "package.json", match: "present (no typescript)" }],
+  };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/language/kotlin.mjs

@@ -0,0 +1,48 @@
+import { isFile, readText, walk } from "../_fs.mjs";
+
+export const id = "kotlin";
+export const kind = "language";
+
+export async function detect(cwd) {
+  const evidence = [];
+  let strong = false;
+
+  if (isFile(cwd, "build.gradle.kts")) {
+    const body = readText(cwd, "build.gradle.kts") || "";
+    evidence.push({ type: "file", where: "build.gradle.kts", match: "present" });
+    if (/\bkotlin\b/i.test(body)) {
+      strong = true;
+      evidence.push({
+        type: "file",
+        where: "build.gradle.kts",
+        match: "kotlin plugin referenced",
+      });
+    }
+  }
+
+  const hasGradle =
+    isFile(cwd, "build.gradle") ||
+    isFile(cwd, "build.gradle.kts") ||
+    isFile(cwd, "settings.gradle") ||
+    isFile(cwd, "settings.gradle.kts");
+  if (hasGradle) {
+    const files = walk(cwd, { maxDepth: 4, maxFiles: 400 });
+    const kt = files.find((f) => f.endsWith(".kt"));
+    if (kt) evidence.push({ type: "file", where: kt, match: "*.kt present" });
+    if (kt && !strong) {
+      return { present: true, confidence: 0.7, evidence };
+    }
+  }
+
+  if (strong) return { present: true, confidence: 1, evidence };
+  if (evidence.length) return { present: true, confidence: 0.6, evidence };
+  return { present: false, confidence: 0, evidence: [] };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}

package/lib/adapters/language/py.mjs

@@ -0,0 +1,34 @@
+import { isFile, listDir } from "../_fs.mjs";
+
+export const id = "py";
+export const kind = "language";
+
+export async function detect(cwd) {
+  const evidence = [];
+  let hit = false;
+
+  if (isFile(cwd, "pyproject.toml")) {
+    hit = true;
+    evidence.push({ type: "file", where: "pyproject.toml", match: "present" });
+  }
+  if (isFile(cwd, "setup.py")) {
+    hit = true;
+    evidence.push({ type: "file", where: "setup.py", match: "present" });
+  }
+  for (const name of listDir(cwd, ".")) {
+    if (/^requirements.*\.txt$/.test(name) && isFile(cwd, name)) {
+      hit = true;
+      evidence.push({ type: "file", where: name, match: "present" });
+    }
+  }
+
+  return { present: hit, confidence: hit ? 1 : 0, evidence };
+}
+
+export async function bootstrap() {
+  return { todo: true };
+}
+
+export async function verify() {
+  return { todo: true };
+}