@monoes/monograph 1.5.6 → 1.5.8

package/src/coverage/upload-inventory.ts

@@ -1,84 +0,0 @@
-// Walks source files, extracts function declarations, and uploads a keyed inventory
-// for the "untracked functions" three-state coverage model.
-
-export const INVENTORY_MAX_FUNCTIONS = 200_000;
-
-export interface InventoryFunction {
-  name: string;
-  filePath: string;
-  startLine: number;   // 1-based, Istanbul-compatible
-  endLine: number;
-}
-
-export interface UploadInventoryArgs {
-  projectId: string;
-  root: string;
-  pathPrefix?: string;
-  apiKey?: string;
-  apiBase?: string;
-  failOnDirty?: boolean;
-}
-
-export interface UploadInventoryResult {
-  uploaded: number;
-  skipped: number;
-  warnings: string[];
-}
-
-/** Rebase container WORKDIR path prefix to repo-relative path. */
-export function normalizePathPrefix(raw: string): string {
-  return raw.replace(/\\/g, '/').replace(/\/$/, '');
-}
-
-/** Attempt to derive a project ID slug from a git remote URL. */
-export function parseGitRemoteToProjectId(url: string): string {
-  const match = url.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
-  return match ? match[1].replace('/', '_') : 'unknown';
-}
-
-/** Extract function inventory from a source text (heuristic, no full AST). */
-export function extractFunctionInventory(source: string, filePath: string): InventoryFunction[] {
-  const results: InventoryFunction[] = [];
-  const lines = source.split('\n');
-  const funcRe = /(?:^|\s)(?:function|async function|const|let|var)\s+([a-zA-Z_$][\w$]*)\s*(?:=\s*(?:async\s*)?\(|[(<])/;
-  const arrowRe = /(?:^|\s)(?:const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=\s*(?:async\s*)?\(/;
-  const methodRe = /^\s*(?:async\s+)?([a-zA-Z_$][\w$]*)\s*\(/;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const m = funcRe.exec(line) ?? arrowRe.exec(line) ?? methodRe.exec(line);
-    if (m && m[1] && !['if', 'while', 'for', 'switch', 'catch'].includes(m[1])) {
-      results.push({ name: m[1], filePath, startLine: i + 1, endLine: i + 1 });
-    }
-  }
-  return results;
-}
-
-/** Upload a function inventory to the cloud API. */
-export async function uploadInventory(
-  args: UploadInventoryArgs,
-  functions: InventoryFunction[],
-): Promise<UploadInventoryResult> {
-  const base = args.apiBase ?? 'https://api.fallow.cloud/v1';
-  const capped = functions.slice(0, INVENTORY_MAX_FUNCTIONS);
-  const warnings: string[] = [];
-  if (functions.length > INVENTORY_MAX_FUNCTIONS) {
-    warnings.push(`Inventory capped at ${INVENTORY_MAX_FUNCTIONS} functions (${functions.length} found)`);
-  }
-
-  const res = await fetch(`${base}/projects/${encodeURIComponent(args.projectId)}/inventory`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${args.apiKey ?? ''}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({ functions: capped, pathPrefix: args.pathPrefix }),
-  });
-
-  if (!res.ok) {
-    warnings.push(`Upload failed: HTTP ${res.status}`);
-    return { uploaded: 0, skipped: functions.length, warnings };
-  }
-
-  return { uploaded: capped.length, skipped: functions.length - capped.length, warnings };
-}

package/src/coverage/upload-source-maps.ts

@@ -1,97 +0,0 @@
-// Uploads .map source map files to the cloud for bundled runtime coverage remapping.
-
-export interface UploadSourceMapsArgs {
-  projectId: string;
-  sourceDir: string;
-  include?: string[];
-  exclude?: string[];
-  stripPath?: string;
-  concurrency?: number;
-  retries?: number;
-  failFast?: boolean;
-  apiKey?: string;
-  apiBase?: string;
-}
-
-export interface SourceMapFile {
-  originalPath: string;
-  uploadPath: string;
-  sizeBytes: number;
-}
-
-export interface UploadSourceMapsResult {
-  uploaded: number;
-  failed: number;
-  skipped: number;
-  warnings: string[];
-}
-
-/** Strip a path prefix from a file path. */
-export function applyStripPath(filePath: string, strip: string): string {
-  const normalized = filePath.replace(/\\/g, '/');
-  const s = strip.replace(/\\/g, '/').replace(/\/$/, '') + '/';
-  return normalized.startsWith(s) ? normalized.slice(s.length) : normalized;
-}
-
-/** Collect .map files from a directory (shallow heuristic — no actual fs walk in library mode). */
-export function collectSourceMaps(
-  files: string[],
-  include: string[] = ['**/*.map'],
-  exclude: string[] = ['node_modules'],
-  stripPath?: string,
-): SourceMapFile[] {
-  return files
-    .filter(f => f.endsWith('.map'))
-    .filter(f => !exclude.some(e => f.includes(e)))
-    .filter(f => include.length === 0 || include.some(_p => f.endsWith('.map')))
-    .map(f => ({
-      originalPath: f,
-      uploadPath: stripPath ? applyStripPath(f, stripPath) : f,
-      sizeBytes: 0,
-    }));
-}
-
-/** Upload source map files to the cloud API. */
-export async function uploadSourceMaps(
-  args: UploadSourceMapsArgs,
-  files: SourceMapFile[],
-): Promise<UploadSourceMapsResult> {
-  const base = args.apiBase ?? 'https://api.fallow.cloud/v1';
-  const concurrency = args.concurrency ?? 4;
-  let uploaded = 0;
-  let failed = 0;
-  const warnings: string[] = [];
-
-  const chunks: SourceMapFile[][] = [];
-  for (let i = 0; i < files.length; i += concurrency) {
-    chunks.push(files.slice(i, i + concurrency));
-  }
-
-  for (const chunk of chunks) {
-    const results = await Promise.allSettled(chunk.map(async f => {
-      const res = await fetch(
-        `${base}/projects/${encodeURIComponent(args.projectId)}/source-maps`,
-        {
-          method: 'POST',
-          headers: {
-            Authorization: `Bearer ${args.apiKey ?? ''}`,
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({ path: f.uploadPath }),
-        },
-      );
-      if (!res.ok) throw new Error(`HTTP ${res.status} for ${f.uploadPath}`);
-    }));
-    for (const r of results) {
-      if (r.status === 'fulfilled') uploaded++;
-      else {
-        failed++;
-        warnings.push(r.reason instanceof Error ? r.reason.message : String(r.reason));
-        if (args.failFast) break;
-      }
-    }
-    if (args.failFast && failed > 0) break;
-  }
-
-  return { uploaded, failed, skipped: 0, warnings };
-}

package/src/discover/entry-points.ts

@@ -1,51 +0,0 @@
-export type EntryPointCategory = "all" | "runtime" | "test";
-
-export type EntryPointSource =
-  | 'package-json-main'
-  | 'package-json-bin'
-  | 'package-json-exports'
-  | 'tsconfig'
-  | 'workspace'
-  | 'config'
-  | 'manual';
-
-export interface CategorizedEntryPoints {
-  all: string[];
-  runtime: string[];
-  test: string[];
-}
-
-export const OUTPUT_DIRS: string[] = ["dist", "build", "out", "esm", "cjs", ".next", ".nuxt", ".output"];
-
-export function isTestEntryPoint(filePath: string): boolean {
-  return (
-    filePath.includes("/__tests__/") ||
-    filePath.includes(".test.") ||
-    filePath.includes(".spec.") ||
-    filePath.includes("/test/") ||
-    filePath.includes("/tests/")
-  );
-}
-
-export function categorizeEntryPoints(entryPoints: string[]): CategorizedEntryPoints {
-  const result: CategorizedEntryPoints = { all: [], runtime: [], test: [] };
-
-  for (const ep of entryPoints) {
-    result.all.push(ep);
-    if (isTestEntryPoint(ep)) {
-      result.test.push(ep);
-    } else {
-      result.runtime.push(ep);
-    }
-  }
-
-  return result;
-}
-
-export function formatSkippedEntryWarning(filePath: string, reason: string): string {
-  return `Skipped entry point ${filePath}: ${reason}`;
-}
-
-export function deduplicateEntryPoints(entries: string[]): string[] {
-  return [...new Set(entries)];
-}

package/src/discover/infrastructure-entries.ts

@@ -1,175 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-export type InfraFileKind =
-  | 'dockerfile'
-  | 'docker-compose'
-  | 'procfile'
-  | 'fly-toml'
-  | 'render-yaml'
-  | 'railway-toml'
-  | 'heroku-procfile';
-
-export interface InfraEntryPoint {
-  filePath: string;
-  kind: InfraFileKind;
-  discoveredEntries: string[];
-}
-
-const JSTS = /\.(js|ts|mjs|cjs)$/;
-
-const STATIC_CANDIDATES: Array<{ filename: string; kind: InfraFileKind }> = [
-  { filename: 'Dockerfile', kind: 'dockerfile' },
-  { filename: 'Procfile', kind: 'heroku-procfile' },
-  { filename: 'fly.toml', kind: 'fly-toml' },
-  { filename: 'render.yaml', kind: 'render-yaml' },
-  { filename: 'railway.toml', kind: 'railway-toml' },
-  { filename: 'docker-compose.yml', kind: 'docker-compose' },
-  { filename: 'docker-compose.yaml', kind: 'docker-compose' },
-];
-
-const COMMON_SUBDIRS = ['app', 'src', 'backend', 'server', 'api', 'services'];
-
-function safeRead(filePath: string): string | null {
-  try {
-    return readFileSync(filePath, 'utf8');
-  } catch {
-    return null;
-  }
-}
-
-function safeLs(dir: string): string[] {
-  try {
-    return readdirSync(dir) as string[];
-  } catch {
-    return [];
-  }
-}
-
-function parseByKind(kind: InfraFileKind, content: string): string[] {
-  switch (kind) {
-    case 'dockerfile':
-      return parseDockerfileEntries(content);
-    case 'heroku-procfile':
-    case 'procfile':
-      return parseProcfileEntries(content);
-    case 'docker-compose':
-      return parseDockerComposeEntries(content);
-    case 'fly-toml':
-    case 'render-yaml':
-    case 'railway-toml':
-      return parseTomlYamlCommandEntries(content);
-  }
-}
-
-function parseDockerComposeEntries(content: string): string[] {
-  const entries: string[] = [];
-  for (const line of content.split('\n')) {
-    const t = line.trim();
-    if (!t.startsWith('command:') && !t.startsWith('entrypoint:')) continue;
-    for (const token of t.split(/\s+/)) {
-      if (JSTS.test(token)) entries.push(token);
-    }
-  }
-  return entries;
-}
-
-function parseTomlYamlCommandEntries(content: string): string[] {
-  const entries: string[] = [];
-  for (const line of content.split('\n')) {
-    const t = line.trim();
-    if (!/^(command|entrypoint)\s*[=:]/.test(t)) continue;
-    for (const token of t.split(/\s+/)) {
-      if (JSTS.test(token)) entries.push(token);
-    }
-  }
-  return entries;
-}
-
-function probeDir(dir: string, seen: Set<string>, results: InfraEntryPoint[]): void {
-  for (const { filename, kind } of STATIC_CANDIDATES) {
-    const filePath = join(dir, filename);
-    if (seen.has(filePath) || !existsSync(filePath)) continue;
-    seen.add(filePath);
-    const content = safeRead(filePath);
-    if (content !== null) {
-      results.push({ filePath, kind, discoveredEntries: parseByKind(kind, content) });
-    }
-  }
-
-  for (const entry of safeLs(dir)) {
-    if (entry.startsWith('Dockerfile.') || entry.startsWith('dockerfile.')) {
-      const filePath = join(dir, entry);
-      if (seen.has(filePath)) continue;
-      seen.add(filePath);
-      const content = safeRead(filePath);
-      if (content !== null) {
-        results.push({ filePath, kind: 'dockerfile', discoveredEntries: parseDockerfileEntries(content) });
-      }
-    }
-  }
-}
-
-export function detectInfraFiles(projectRoot: string): InfraEntryPoint[] {
-  const results: InfraEntryPoint[] = [];
-  const seen = new Set<string>();
-
-  probeDir(projectRoot, seen, results);
-  for (const sub of COMMON_SUBDIRS) {
-    probeDir(join(projectRoot, sub), seen, results);
-  }
-
-  return results;
-}
-
-export function parseDockerfileEntries(content: string): string[] {
-  const entries: string[] = [];
-
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith('CMD') && !trimmed.startsWith('ENTRYPOINT')) continue;
-
-    const jsonMatch = trimmed.match(/\[([^\]]+)\]/);
-    if (jsonMatch) {
-      try {
-        const parts = JSON.parse(`[${jsonMatch[1]}]`) as unknown[];
-        for (const part of parts) {
-          if (typeof part === 'string' && JSTS.test(part)) entries.push(part);
-        }
-      } catch {
-        // malformed JSON array — fall through to shell-form parse below
-        const rest = trimmed.replace(/^(CMD|ENTRYPOINT)\s+/, '');
-        for (const token of rest.split(/\s+/)) {
-          if (JSTS.test(token)) entries.push(token);
-        }
-      }
-      continue;
-    }
-
-    const rest = trimmed.replace(/^(CMD|ENTRYPOINT)\s+/, '');
-    for (const token of rest.split(/\s+/)) {
-      if (JSTS.test(token)) entries.push(token);
-    }
-  }
-
-  return entries;
-}
-
-export function parseProcfileEntries(content: string): string[] {
-  const entries: string[] = [];
-
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-
-    const colonIdx = trimmed.indexOf(':');
-    if (colonIdx === -1) continue;
-
-    const command = trimmed.slice(colonIdx + 1).trim();
-    for (const token of command.split(/\s+/)) {
-      if (JSTS.test(token)) entries.push(token);
-    }
-  }
-
-  return entries;
-}

package/src/duplicates/detect/concatenation.ts

@@ -1,37 +0,0 @@
-export interface ConcatenationResult {
-  text: number[];
-  fileOf: number[];
-  fileOffsets: number[];
-}
-
-export function concatenateWithSentinels(
-  fileTokens: Array<{ fileId: number; tokens: number[] }>,
-): ConcatenationResult {
-  const sentinelCount = Math.max(0, fileTokens.length - 1);
-  const totalLen = fileTokens.reduce((s, f) => s + f.tokens.length, 0) + sentinelCount;
-
-  const text: number[] = [];
-  const fileOf: number[] = [];
-  const fileOffsets: number[] = [];
-
-  let sentinel = -1;
-
-  for (let i = 0; i < fileTokens.length; i++) {
-    const { fileId, tokens } = fileTokens[i];
-    fileOffsets.push(text.length);
-
-    for (const r of tokens) {
-      text.push(r);
-      fileOf.push(fileId);
-    }
-
-    if (i + 1 < fileTokens.length) {
-      text.push(sentinel);
-      fileOf.push(-1);
-      sentinel -= 1;
-    }
-  }
-
-  void totalLen;
-  return { text, fileOf, fileOffsets };
-}

package/src/duplicates/detect/extraction.ts

@@ -1,107 +0,0 @@
-export interface RawInstance {
-  fileId: number;
-  offset: number;
-}
-
-export interface RawGroup {
-  instances: RawInstance[];
-  lcpLength: number;
-}
-
-export function extractCloneGroups(
-  sa: number[],
-  lcp: number[],
-  fileOf: number[],
-  fileOffsets: number[],
-  minTokens: number,
-  focusFileIds?: Set<number>,
-): RawGroup[] {
-  const n = sa.length;
-  if (n < 2) return [];
-
-  const focusPrefix = focusFileIds !== undefined ? buildFocusPrefix(sa, fileOf, focusFileIds) : null;
-
-  const stack: Array<{ lcpVal: number; start: number }> = [];
-  const groups: RawGroup[] = [];
-
-  for (let i = 1; i <= n; i++) {
-    const curLcp = i < n ? lcp[i] : 0;
-    let start = i;
-
-    while (stack.length > 0) {
-      const top = stack[stack.length - 1];
-      if (top.lcpVal <= curLcp) break;
-      stack.pop();
-      start = top.start;
-
-      if (top.lcpVal >= minTokens) {
-        const intervalBegin = start - 1;
-        const intervalEnd = i;
-
-        if (focusPrefix !== null && !intervalHasFocus(focusPrefix, intervalBegin, intervalEnd)) {
-          continue;
-        }
-
-        const group = buildRawGroup(sa, fileOf, fileOffsets, intervalBegin, intervalEnd, top.lcpVal);
-        if (group !== null) groups.push(group);
-      }
-    }
-
-    if (i < n) {
-      stack.push({ lcpVal: curLcp, start });
-    }
-  }
-
-  return groups;
-}
-
-function buildFocusPrefix(sa: number[], fileOf: number[], focusFileIds: Set<number>): number[] {
-  const prefix = new Array<number>(sa.length + 1).fill(0);
-  for (let i = 0; i < sa.length; i++) {
-    const pos = sa[i];
-    const fid = fileOf[pos];
-    const focused = fid !== -1 && focusFileIds.has(fid) ? 1 : 0;
-    prefix[i + 1] = prefix[i] + focused;
-  }
-  return prefix;
-}
-
-function intervalHasFocus(focusPrefix: number[], begin: number, end: number): boolean {
-  return focusPrefix[end] > focusPrefix[begin];
-}
-
-function buildRawGroup(
-  sa: number[],
-  fileOf: number[],
-  fileOffsets: number[],
-  intervalBegin: number,
-  intervalEnd: number,
-  length: number,
-): RawGroup | null {
-  const instances: Array<{ fileId: number; offset: number }> = [];
-
-  for (let idx = intervalBegin; idx < intervalEnd; idx++) {
-    const pos = sa[idx];
-    const fid = fileOf[pos];
-    if (fid === -1) continue;
-    const offset = pos - fileOffsets[fid];
-    instances.push({ fileId: fid, offset });
-  }
-
-  if (instances.length < 2) return null;
-
-  instances.sort((a, b) => a.fileId !== b.fileId ? a.fileId - b.fileId : a.offset - b.offset);
-
-  const deduped: RawInstance[] = [];
-  for (const inst of instances) {
-    const last = deduped[deduped.length - 1];
-    if (last !== undefined && inst.fileId === last.fileId && inst.offset < last.offset + length) {
-      continue;
-    }
-    deduped.push(inst);
-  }
-
-  if (deduped.length < 2) return null;
-
-  return { instances: deduped, lcpLength: length };
-}

package/src/duplicates/detect/filtering.ts

@@ -1,112 +0,0 @@
-import type { RawGroup } from './extraction.js';
-
-export interface Interval {
-  start: number;
-  end: number;
-}
-
-export class IntervalIndex {
-  private intervals: Array<{ start: number; end: number }> = [];
-
-  insert(interval: Interval): void {
-    const { start, end } = interval;
-    const lo = this.partitionByEnd(start);
-    const hi = this.partitionByStart(end);
-
-    if (lo === hi) {
-      this.intervals.splice(lo, 0, { start, end });
-    } else {
-      const mergedStart = Math.min(this.intervals[lo].start, start);
-      const mergedEnd = Math.max(this.intervals[hi - 1].end, end);
-      this.intervals.splice(lo, hi - lo, { start: mergedStart, end: mergedEnd });
-    }
-  }
-
-  contains(interval: Interval): boolean {
-    const { start, end } = interval;
-    const idx = this.partitionByStart(start + 1) - 1;
-    if (idx < 0) return false;
-    const iv = this.intervals[idx];
-    return iv.start <= start && end <= iv.end;
-  }
-
-  overlaps(interval: Interval): boolean {
-    const { start, end } = interval;
-    const lo = this.partitionByEnd(start);
-    if (lo >= this.intervals.length) return false;
-    return this.intervals[lo].start < end;
-  }
-
-  private partitionByEnd(val: number): number {
-    let lo = 0;
-    let hi = this.intervals.length;
-    while (lo < hi) {
-      const mid = (lo + hi) >>> 1;
-      if (this.intervals[mid].end < val) lo = mid + 1;
-      else hi = mid;
-    }
-    return lo;
-  }
-
-  private partitionByStart(val: number): number {
-    let lo = 0;
-    let hi = this.intervals.length;
-    while (lo < hi) {
-      const mid = (lo + hi) >>> 1;
-      if (this.intervals[mid].start <= val) lo = mid + 1;
-      else hi = mid;
-    }
-    return lo;
-  }
-}
-
-export function filterCloneGroups(
-  groups: RawGroup[],
-  fileOffsets: number[],
-  fileOf: number[],
-  minLines: number,
-  lineCount: (fileId: number, offset: number, length: number) => number,
-): RawGroup[] {
-  const sorted = [...groups].sort((a, b) => b.lcpLength - a.lcpLength);
-
-  const numFiles = fileOffsets.length;
-  const covered = new Map<number, IntervalIndex>();
-
-  const getIndex = (fid: number): IntervalIndex => {
-    let idx = covered.get(fid);
-    if (!idx) {
-      idx = new IntervalIndex();
-      covered.set(fid, idx);
-    }
-    return idx;
-  };
-
-  const result: RawGroup[] = [];
-
-  for (const group of sorted) {
-    const len = group.lcpLength;
-
-    const allCovered = group.instances.every((inst) => {
-      const idx = covered.get(inst.fileId);
-      if (!idx) return false;
-      return idx.contains({ start: inst.offset, end: inst.offset + len });
-    });
-
-    if (allCovered) continue;
-
-    const lines = Math.max(
-      ...group.instances.map((inst) => lineCount(inst.fileId, inst.offset, len)),
-    );
-    if (lines < minLines) continue;
-
-    for (const inst of group.instances) {
-      getIndex(inst.fileId).insert({ start: inst.offset, end: inst.offset + len });
-    }
-
-    result.push(group);
-  }
-
-  void numFiles;
-  void fileOf;
-  return result;
-}

package/src/duplicates/detect/lcp.ts

@@ -1,27 +0,0 @@
-export function buildLcp(text: number[], sa: number[]): number[] {
-  const n = sa.length;
-  if (n === 0) return [];
-
-  const rank = new Int32Array(n);
-  for (let i = 0; i < n; i++) rank[sa[i]] = i;
-
-  const lcp = new Array<number>(n).fill(0);
-  let k = 0;
-
-  for (let i = 0; i < n; i++) {
-    if (rank[i] === 0) {
-      k = 0;
-      continue;
-    }
-    const j = sa[rank[i] - 1];
-    while (i + k < n && j + k < n) {
-      if (text[i + k] < 0 || text[j + k] < 0) break;
-      if (text[i + k] !== text[j + k]) break;
-      k++;
-    }
-    lcp[rank[i]] = k;
-    k = k > 0 ? k - 1 : 0;
-  }
-
-  return lcp;
-}