@h-rig/docs-drift-plugin 0.0.6-alpha.156

package/README.md

@@ -0,0 +1 @@
+# @h-rig/docs-drift-plugin

package/dist/src/drift/detect.d.ts

@@ -0,0 +1,11 @@
+import type { DriftFinding, DriftReport } from "@rig/contracts";
+import { type DriftGit } from "./git-adapter";
+export interface DriftDetectOptions {
+    readonly projectRoot: string;
+    readonly docsGlobs?: readonly string[];
+    readonly ignoreGlobs?: readonly string[];
+    readonly git?: DriftGit;
+}
+export declare function detectDeletedReferences(projectRoot: string, docPath: string, git?: DriftGit): Promise<readonly DriftFinding[]>;
+export declare function detectStaleAnchors(projectRoot: string, docPath: string, git?: DriftGit): Promise<readonly DriftFinding[]>;
+export declare function detectDrift(options: DriftDetectOptions): Promise<DriftReport>;

package/dist/src/drift/detect.js

@@ -0,0 +1,299 @@
+// @bun
+// packages/docs-drift-plugin/src/drift/detect.ts
+import { existsSync } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
+import { basename, extname, relative, resolve } from "path";
+
+// packages/docs-drift-plugin/src/drift/extract-refs.ts
+var INLINE_CODE = /`([^`\n]+)`/g;
+var MARKDOWN_LINK = /\[[^\]]+\]\(([^)\s]+)\)/g;
+var SYMBOL_REF = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$/;
+var PATH_REF = /^(?:\.\.?\/)?(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+$|^[A-Za-z0-9_.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|mdx|css|scss|html|yml|yaml|toml|rs|go|py|rb|java|kt|swift|c|cc|cpp|h|hpp)$/;
+function stripFenceLines(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  let fenced = false;
+  return lines.map((line) => {
+    if (/^\s*(```|~~~)/.test(line)) {
+      fenced = !fenced;
+      return "";
+    }
+    return fenced ? "" : line;
+  });
+}
+function normalizeToken(raw) {
+  return raw.trim().replace(/^['"]|['"]$/g, "").replace(/[),.;:]+$/g, "").replace(/#L\d+(?:-L\d+)?$/i, "");
+}
+function classifyReference(raw) {
+  if (raw.startsWith("@"))
+    return null;
+  if (PATH_REF.test(raw))
+    return "path";
+  if (SYMBOL_REF.test(raw))
+    return "symbol";
+  return null;
+}
+function pushReference(refs, seen, raw, line) {
+  const value = normalizeToken(raw);
+  if (!value)
+    return;
+  const kind = classifyReference(value);
+  if (!kind)
+    return;
+  const key = `${kind}:${value}:${line}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  refs.push({ kind, value, line });
+}
+function extractDriftReferences(markdown) {
+  const refs = [];
+  const seen = new Set;
+  const lines = stripFenceLines(markdown);
+  for (const [index, line] of lines.entries()) {
+    const lineNumber = index + 1;
+    for (const match of line.matchAll(INLINE_CODE)) {
+      pushReference(refs, seen, match[1] ?? "", lineNumber);
+    }
+    for (const match of line.matchAll(MARKDOWN_LINK)) {
+      pushReference(refs, seen, match[1] ?? "", lineNumber);
+    }
+  }
+  return refs;
+}
+
+// packages/docs-drift-plugin/src/drift/git-adapter.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function processError(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function lineCount(output) {
+  const trimmed = output.trim();
+  return trimmed ? trimmed.split(/\r?\n/).length : 0;
+}
+function makeDriftGit(projectRoot) {
+  async function git(args) {
+    const result = await execFileAsync("git", [...args], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return String(result.stdout);
+  }
+  async function grepCountAt(symbolOrPath, commit) {
+    try {
+      return lineCount(await git(["grep", "-F", "-n", "-e", symbolOrPath, commit, "--"]));
+    } catch (error) {
+      const detail = processError(error);
+      if (detail?.code === 1)
+        return 0;
+      throw error;
+    }
+  }
+  return {
+    async lastCommitTouching(path) {
+      const commit = (await git(["log", "-n", "1", "--format=%H", "--", path])).trim();
+      return commit || "HEAD";
+    },
+    async grepCount(symbolOrPath) {
+      return grepCountAt(symbolOrPath, "HEAD");
+    },
+    async grepCountAtCommit(symbolOrPath, commit) {
+      return grepCountAt(symbolOrPath, commit);
+    },
+    async wasRenamed(symbolOrPath, sinceCommit) {
+      if (!symbolOrPath.includes("/") && !symbolOrPath.includes("."))
+        return false;
+      try {
+        const output = await git(["log", "--name-status", "--format=", `${sinceCommit}..HEAD`]);
+        return output.split(/\r?\n/).some((line) => {
+          const match = line.match(/^R\d*\s+(.+?)\s+(.+)$/);
+          return Boolean(match && (match[1] === symbolOrPath || match[2] === symbolOrPath));
+        });
+      } catch (error) {
+        const detail = processError(error);
+        if (detail?.code === 128)
+          return false;
+        throw error;
+      }
+    }
+  };
+}
+
+// packages/docs-drift-plugin/src/drift/detect.ts
+var DEFAULT_IGNORED_DIRS = {
+  ".git": true,
+  node_modules: true,
+  dist: true,
+  build: true,
+  coverage: true,
+  ".next": true,
+  vendor: true
+};
+var SOURCE_EXTENSIONS = {
+  ".ts": true,
+  ".tsx": true,
+  ".js": true,
+  ".jsx": true,
+  ".mjs": true,
+  ".cjs": true,
+  ".rs": true,
+  ".go": true,
+  ".py": true,
+  ".rb": true,
+  ".java": true,
+  ".kt": true,
+  ".swift": true,
+  ".c": true,
+  ".cc": true,
+  ".cpp": true,
+  ".h": true,
+  ".hpp": true,
+  ".json": true,
+  ".toml": true,
+  ".yml": true,
+  ".yaml": true
+};
+function globLikeMatch(path, pattern) {
+  if (pattern === path)
+    return true;
+  if (pattern.startsWith("**/*"))
+    return path.endsWith(pattern.slice(4));
+  if (pattern.endsWith("/**"))
+    return path.startsWith(pattern.slice(0, -3));
+  if (pattern.includes("*")) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`).test(path);
+  }
+  return path.startsWith(pattern);
+}
+function isDefaultDoc(path) {
+  const lower = basename(path).toLowerCase();
+  return (path.endsWith(".md") || path.endsWith(".mdx")) && !lower.startsWith("changelog") && !lower.includes("generated");
+}
+function isIgnored(path, patterns) {
+  return (patterns ?? []).some((pattern) => globLikeMatch(path, pattern));
+}
+async function collectFiles(root, options) {
+  const files = [];
+  async function visit(dir) {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && DEFAULT_IGNORED_DIRS[entry.name])
+        continue;
+      const absolute = resolve(dir, entry.name);
+      const rel = relative(root, absolute).replace(/\\/g, "/");
+      if (isIgnored(rel, options.ignore))
+        continue;
+      if (entry.isDirectory()) {
+        await visit(absolute);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      if (options.docs) {
+        const matchesConfigured = options.patterns && options.patterns.length > 0 ? options.patterns.some((pattern) => globLikeMatch(rel, pattern)) : isDefaultDoc(rel);
+        if (matchesConfigured)
+          files.push(rel);
+        continue;
+      }
+      if (SOURCE_EXTENSIONS[extname(entry.name)])
+        files.push(rel);
+    }
+  }
+  await visit(root);
+  return files.sort();
+}
+async function sourceReferenceCount(projectRoot, reference, docPath) {
+  if (reference.kind === "path")
+    return existsSync(resolve(projectRoot, reference.value)) ? 1 : 0;
+  let count = 0;
+  const sourceFiles = await collectFiles(projectRoot, { docs: false });
+  for (const sourceFile of sourceFiles) {
+    if (sourceFile === docPath)
+      continue;
+    const text = await readFile(resolve(projectRoot, sourceFile), "utf8").catch(() => "");
+    if (text.includes(reference.value))
+      count += 1;
+  }
+  return count;
+}
+function deletedReferenceFinding(docPath, reference) {
+  return {
+    kind: "deleted-reference",
+    docPath,
+    line: reference.line,
+    reference: reference.value,
+    detail: `Documented reference "${reference.value}" no longer exists in the source tree.`,
+    confidence: "high"
+  };
+}
+function staleAnchorFinding(docPath, reference) {
+  return {
+    kind: "stale-anchor",
+    docPath,
+    line: reference.line,
+    reference: reference.value,
+    detail: `Documented path "${reference.value}" changed after this doc was last updated.`,
+    confidence: "medium"
+  };
+}
+async function detectDeletedReferences(projectRoot, docPath, git = makeDriftGit(projectRoot)) {
+  const markdown = await readFile(resolve(projectRoot, docPath), "utf8");
+  const docCommit = await git.lastCommitTouching(docPath);
+  const findings = [];
+  for (const reference of extractDriftReferences(markdown)) {
+    if (await sourceReferenceCount(projectRoot, reference, docPath) > 0)
+      continue;
+    if (await git.wasRenamed(reference.value, docCommit))
+      continue;
+    findings.push(deletedReferenceFinding(docPath, reference));
+  }
+  return findings;
+}
+async function detectStaleAnchors(projectRoot, docPath, git = makeDriftGit(projectRoot)) {
+  const markdown = await readFile(resolve(projectRoot, docPath), "utf8");
+  const docCommit = await git.lastCommitTouching(docPath);
+  const findings = [];
+  for (const reference of extractDriftReferences(markdown).filter((ref) => ref.kind === "path")) {
+    if (!existsSync(resolve(projectRoot, reference.value)))
+      continue;
+    const sourceStat = await stat(resolve(projectRoot, reference.value)).catch(() => null);
+    if (!sourceStat?.isFile())
+      continue;
+    const sourceCommit = await git.lastCommitTouching(reference.value);
+    if (sourceCommit !== docCommit && !await git.wasRenamed(reference.value, docCommit)) {
+      findings.push(staleAnchorFinding(docPath, reference));
+    }
+  }
+  return findings;
+}
+async function detectDrift(options) {
+  const git = options.git ?? makeDriftGit(options.projectRoot);
+  const docs = await collectFiles(options.projectRoot, {
+    docs: true,
+    ...options.docsGlobs !== undefined ? { patterns: options.docsGlobs } : {},
+    ...options.ignoreGlobs !== undefined ? { ignore: options.ignoreGlobs } : {}
+  });
+  const findings = [];
+  let degraded = false;
+  for (const docPath of docs) {
+    try {
+      findings.push(...await detectDeletedReferences(options.projectRoot, docPath, git));
+      findings.push(...await detectStaleAnchors(options.projectRoot, docPath, git));
+    } catch {
+      degraded = true;
+    }
+  }
+  return {
+    generatedAt: new Date().toISOString(),
+    scanned: docs.length,
+    degraded,
+    findings
+  };
+}
+export {
+  detectStaleAnchors,
+  detectDrift,
+  detectDeletedReferences
+};

package/dist/src/drift/extract-refs.d.ts

@@ -0,0 +1,7 @@
+export type DriftReferenceKind = "symbol" | "path";
+export interface DriftReference {
+    readonly kind: DriftReferenceKind;
+    readonly value: string;
+    readonly line: number;
+}
+export declare function extractDriftReferences(markdown: string): readonly DriftReference[];

package/dist/src/drift/extract-refs.js

@@ -0,0 +1,60 @@
+// @bun
+// packages/docs-drift-plugin/src/drift/extract-refs.ts
+var INLINE_CODE = /`([^`\n]+)`/g;
+var MARKDOWN_LINK = /\[[^\]]+\]\(([^)\s]+)\)/g;
+var SYMBOL_REF = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$/;
+var PATH_REF = /^(?:\.\.?\/)?(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+$|^[A-Za-z0-9_.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|mdx|css|scss|html|yml|yaml|toml|rs|go|py|rb|java|kt|swift|c|cc|cpp|h|hpp)$/;
+function stripFenceLines(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  let fenced = false;
+  return lines.map((line) => {
+    if (/^\s*(```|~~~)/.test(line)) {
+      fenced = !fenced;
+      return "";
+    }
+    return fenced ? "" : line;
+  });
+}
+function normalizeToken(raw) {
+  return raw.trim().replace(/^['"]|['"]$/g, "").replace(/[),.;:]+$/g, "").replace(/#L\d+(?:-L\d+)?$/i, "");
+}
+function classifyReference(raw) {
+  if (raw.startsWith("@"))
+    return null;
+  if (PATH_REF.test(raw))
+    return "path";
+  if (SYMBOL_REF.test(raw))
+    return "symbol";
+  return null;
+}
+function pushReference(refs, seen, raw, line) {
+  const value = normalizeToken(raw);
+  if (!value)
+    return;
+  const kind = classifyReference(value);
+  if (!kind)
+    return;
+  const key = `${kind}:${value}:${line}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  refs.push({ kind, value, line });
+}
+function extractDriftReferences(markdown) {
+  const refs = [];
+  const seen = new Set;
+  const lines = stripFenceLines(markdown);
+  for (const [index, line] of lines.entries()) {
+    const lineNumber = index + 1;
+    for (const match of line.matchAll(INLINE_CODE)) {
+      pushReference(refs, seen, match[1] ?? "", lineNumber);
+    }
+    for (const match of line.matchAll(MARKDOWN_LINK)) {
+      pushReference(refs, seen, match[1] ?? "", lineNumber);
+    }
+  }
+  return refs;
+}
+export {
+  extractDriftReferences
+};

package/dist/src/drift/git-adapter.d.ts

@@ -0,0 +1,7 @@
+export interface DriftGit {
+    lastCommitTouching(path: string): Promise<string>;
+    grepCount(symbolOrPath: string): Promise<number>;
+    grepCountAtCommit(symbolOrPath: string, commit: string): Promise<number>;
+    wasRenamed(symbolOrPath: string, sinceCommit: string): Promise<boolean>;
+}
+export declare function makeDriftGit(projectRoot: string): DriftGit;

package/dist/src/drift/git-adapter.js

@@ -0,0 +1,63 @@
+// @bun
+// packages/docs-drift-plugin/src/drift/git-adapter.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function processError(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function lineCount(output) {
+  const trimmed = output.trim();
+  return trimmed ? trimmed.split(/\r?\n/).length : 0;
+}
+function makeDriftGit(projectRoot) {
+  async function git(args) {
+    const result = await execFileAsync("git", [...args], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return String(result.stdout);
+  }
+  async function grepCountAt(symbolOrPath, commit) {
+    try {
+      return lineCount(await git(["grep", "-F", "-n", "-e", symbolOrPath, commit, "--"]));
+    } catch (error) {
+      const detail = processError(error);
+      if (detail?.code === 1)
+        return 0;
+      throw error;
+    }
+  }
+  return {
+    async lastCommitTouching(path) {
+      const commit = (await git(["log", "-n", "1", "--format=%H", "--", path])).trim();
+      return commit || "HEAD";
+    },
+    async grepCount(symbolOrPath) {
+      return grepCountAt(symbolOrPath, "HEAD");
+    },
+    async grepCountAtCommit(symbolOrPath, commit) {
+      return grepCountAt(symbolOrPath, commit);
+    },
+    async wasRenamed(symbolOrPath, sinceCommit) {
+      if (!symbolOrPath.includes("/") && !symbolOrPath.includes("."))
+        return false;
+      try {
+        const output = await git(["log", "--name-status", "--format=", `${sinceCommit}..HEAD`]);
+        return output.split(/\r?\n/).some((line) => {
+          const match = line.match(/^R\d*\s+(.+?)\s+(.+)$/);
+          return Boolean(match && (match[1] === symbolOrPath || match[2] === symbolOrPath));
+        });
+      } catch (error) {
+        const detail = processError(error);
+        if (detail?.code === 128)
+          return false;
+        throw error;
+      }
+    }
+  };
+}
+export {
+  makeDriftGit
+};

package/dist/src/drift/judge.d.ts

@@ -0,0 +1,19 @@
+import type { DriftFinding } from "@rig/contracts";
+export interface DriftJudgeInput {
+    readonly docPath: string;
+    readonly docSnippet: string;
+    readonly codeSnippet: string;
+    readonly reference?: string;
+}
+export interface DriftJudgeMismatch {
+    readonly detail: string;
+    readonly reference?: string;
+    readonly line?: number | null;
+    readonly confidence?: "high" | "medium" | "low";
+}
+export interface DriftJudgeProvider {
+    judge(input: DriftJudgeInput): Promise<{
+        readonly mismatches: readonly DriftJudgeMismatch[];
+    }>;
+}
+export declare function judgeDocumentationDrift(provider: DriftJudgeProvider, input: DriftJudgeInput): Promise<readonly DriftFinding[]>;

package/dist/src/drift/judge.js

@@ -0,0 +1,16 @@
+// @bun
+// packages/docs-drift-plugin/src/drift/judge.ts
+async function judgeDocumentationDrift(provider, input) {
+  const result = await provider.judge(input);
+  return result.mismatches.map((mismatch) => ({
+    kind: "semantic-mismatch",
+    docPath: input.docPath,
+    line: mismatch.line ?? null,
+    reference: mismatch.reference ?? input.reference ?? null,
+    detail: mismatch.detail,
+    confidence: mismatch.confidence ?? "medium"
+  }));
+}
+export {
+  judgeDocumentationDrift
+};

package/dist/src/drift/metadata.d.ts

@@ -0,0 +1,13 @@
+import { type StageMutation, type ValidatorRegistration } from "@rig/contracts";
+export interface DocsDriftPluginOptions {
+    readonly docsGlobs?: readonly string[];
+    readonly ignoreGlobs?: readonly string[];
+    readonly failOnDrift?: boolean;
+}
+export declare const DOCS_DRIFT_VALIDATOR_ID = "std:docs-drift";
+export declare const DOCS_DRIFT_CLI_ID = "std:drift";
+export declare const DOCS_DRIFT_STAGE_ID = "docs-drift";
+export declare const DOCS_DRIFT_CAPABILITY_ID = "std:docs-drift-capability";
+export declare const DOCS_DRIFT_VALIDATOR: ValidatorRegistration;
+export declare const DOCS_DRIFT_STAGE_MUTATION: StageMutation;
+export declare const DOCS_DRIFT_CLI_COMMAND = "rig drift [--docs <csv>] [--ignore <csv>] [--fail-on-drift] [--json]";

package/dist/src/drift/metadata.js

@@ -0,0 +1,35 @@
+// @bun
+// packages/docs-drift-plugin/src/drift/metadata.ts
+import { Schema } from "effect";
+import { StageMutation as StageMutationSchema } from "@rig/contracts";
+var DOCS_DRIFT_VALIDATOR_ID = "std:docs-drift";
+var DOCS_DRIFT_CLI_ID = "std:drift";
+var DOCS_DRIFT_STAGE_ID = "docs-drift";
+var DOCS_DRIFT_CAPABILITY_ID = "std:docs-drift-capability";
+var DOCS_DRIFT_VALIDATOR = {
+  id: DOCS_DRIFT_VALIDATOR_ID,
+  category: "regression",
+  description: "Detect documentation references that drifted from the source tree."
+};
+var DOCS_DRIFT_STAGE_MUTATION = Schema.decodeUnknownSync(StageMutationSchema)({
+  op: "insert",
+  stage: {
+    id: DOCS_DRIFT_STAGE_ID,
+    kind: "gate",
+    before: ["merge-gate"],
+    after: ["open-pr"],
+    priority: 0,
+    protected: false
+  },
+  contributedBy: DOCS_DRIFT_STAGE_ID
+});
+var DOCS_DRIFT_CLI_COMMAND = "rig drift [--docs <csv>] [--ignore <csv>] [--fail-on-drift] [--json]";
+export {
+  DOCS_DRIFT_VALIDATOR_ID,
+  DOCS_DRIFT_VALIDATOR,
+  DOCS_DRIFT_STAGE_MUTATION,
+  DOCS_DRIFT_STAGE_ID,
+  DOCS_DRIFT_CLI_ID,
+  DOCS_DRIFT_CLI_COMMAND,
+  DOCS_DRIFT_CAPABILITY_ID
+};

package/dist/src/drift/plugin.d.ts

@@ -0,0 +1,53 @@
+import type { DriftFinding, DriftReport, StageResult, StageRun } from "@rig/contracts";
+import type { Validator, CliCommand, RuntimeCliContext, ValidatorResult } from "@rig/core/config";
+import { type DriftDetectOptions } from "./detect";
+export { DOCS_DRIFT_CAPABILITY_ID, DOCS_DRIFT_CLI_COMMAND, DOCS_DRIFT_CLI_ID, DOCS_DRIFT_STAGE_ID, DOCS_DRIFT_STAGE_MUTATION, DOCS_DRIFT_VALIDATOR, DOCS_DRIFT_VALIDATOR_ID, type DocsDriftPluginOptions, } from "./metadata";
+import { type DocsDriftPluginOptions } from "./metadata";
+export declare function highConfidenceDriftFindings(report: DriftReport): readonly DriftFinding[];
+export declare function driftGateResult(report: DriftReport, mode?: "observe" | "enforce"): StageResult;
+/**
+ * Executable for the `docs-drift` pre-merge gate stage (inserted by
+ * DOCS_DRIFT_STAGE_MUTATION before `merge-gate`). Reads the project root from the
+ * stage context metadata, runs deletion-survival drift detection, and blocks the
+ * pipeline on high-confidence drift when enforcing (`failOnDrift`), else observes.
+ */
+export declare function createDocsDriftGateStage(options?: DocsDriftPluginOptions): StageRun;
+export declare function runDocsDriftValidation(options: DriftDetectOptions & {
+    failOnDrift?: boolean;
+}): Promise<ValidatorResult>;
+export declare function createDocsDriftValidator(options?: DocsDriftPluginOptions): Validator;
+export interface RunDriftCliOptions {
+    readonly projectRoot?: string;
+    readonly write?: (message: string) => void;
+    readonly writeError?: (message: string) => void;
+}
+export declare function executeDrift(context: RuntimeCliContext, args: readonly string[], options?: DocsDriftPluginOptions): Promise<{
+    ok: boolean;
+    group: string;
+    command: string;
+    details: {
+        report: {
+            readonly degraded: boolean;
+            readonly generatedAt: string;
+            readonly findings: readonly {
+                readonly kind: "deleted-reference" | "stale-anchor" | "semantic-mismatch" | "issue-mismatch";
+                readonly detail: string;
+                readonly line: number | null;
+                readonly reference: string | null;
+                readonly docPath: string;
+                readonly confidence: "high" | "medium" | "low";
+            }[];
+            readonly scanned: number;
+        };
+        summary: {
+            total: number;
+            highConfidence: number;
+            degraded: boolean;
+        };
+        failOnDrift: boolean;
+        failed: boolean;
+    };
+}>;
+export declare function createDocsDriftRuntimeCliCommand(options?: DocsDriftPluginOptions): CliCommand;
+export declare const DOCS_DRIFT_RUNTIME_CLI_COMMAND: CliCommand;
+export declare function runDriftCli(args: readonly string[], options?: RunDriftCliOptions): Promise<number>;