@monoes/monograph 1.5.6 → 1.5.8

package/src/license/manager.ts

@@ -1,120 +0,0 @@
-// Offline + online license lifecycle: activate trial, refresh, status, verify JWT.
-
-export type LicenseTier = 'free' | 'trial' | 'pro' | 'enterprise';
-
-export interface LicenseFeatures {
-  cloudCoverage: boolean;
-  mcp: boolean;
-  customRules: boolean;
-  ssoSaml: boolean;
-}
-
-export interface LicenseStatus {
-  tier: LicenseTier;
-  seats: number;
-  features: LicenseFeatures;
-  expiresAt?: Date;
-  daysRemaining?: number;
-  isExpired: boolean;
-  isInWarningWindow: boolean;
-  isWatermarked: boolean;
-}
-
-export interface ActivateOptions {
-  email: string;
-  apiBase?: string;
-  licenseStorePath?: string;
-}
-
-export interface LicenseJwtPayload {
-  sub: string;
-  tier: LicenseTier;
-  seats: number;
-  features: string[];
-  exp: number;
-  iat: number;
-}
-
-export class LicenseError extends Error {
-  constructor(message: string, public readonly code: string) {
-    super(message);
-    this.name = 'LicenseError';
-  }
-}
-
-const WARNING_WINDOW_DAYS = 14;
-const FREE_FEATURES: LicenseFeatures = { cloudCoverage: false, mcp: false, customRules: false, ssoSaml: false };
-
-/** Parse a JWT payload without signature verification (use verifyLicenseJwt for full check). */
-export function parseLicenseJwt(jwt: string): LicenseJwtPayload {
-  const parts = jwt.split('.');
-  if (parts.length !== 3) throw new LicenseError('Malformed JWT', 'MALFORMED_JWT');
-  try {
-    const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
-    return payload as LicenseJwtPayload;
-  } catch {
-    throw new LicenseError('Failed to decode JWT payload', 'DECODE_ERROR');
-  }
-}
-
-/** Derive LicenseStatus from a parsed JWT payload. */
-export function licenseStatusFromPayload(payload: LicenseJwtPayload): LicenseStatus {
-  const expiresAt = new Date(payload.exp * 1000);
-  const now = Date.now();
-  const daysRemaining = Math.ceil((expiresAt.getTime() - now) / 86_400_000);
-  const isExpired = daysRemaining <= 0;
-  const isInWarningWindow = !isExpired && daysRemaining <= WARNING_WINDOW_DAYS;
-  const featureSet = new Set(payload.features ?? []);
-  return {
-    tier: payload.tier,
-    seats: payload.seats ?? 1,
-    features: {
-      cloudCoverage: featureSet.has('cloud_coverage'),
-      mcp: featureSet.has('mcp'),
-      customRules: featureSet.has('custom_rules'),
-      ssoSaml: featureSet.has('sso_saml'),
-    },
-    expiresAt,
-    daysRemaining: Math.max(daysRemaining, 0),
-    isExpired,
-    isInWarningWindow,
-    isWatermarked: isExpired || payload.tier === 'free',
-  };
-}
-
-/** Activate a trial license via the cloud API. */
-export async function activateTrial(opts: ActivateOptions): Promise<string> {
-  const base = opts.apiBase ?? 'https://api.fallow.cloud/v1';
-  const res = await fetch(`${base}/license/trial`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ email: opts.email }),
-  });
-  if (!res.ok) throw new LicenseError(`Activation failed: HTTP ${res.status}`, 'ACTIVATION_FAILED');
-  const data = await res.json() as { jwt: string };
-  return data.jwt;
-}
-
-/** Refresh an existing license JWT. */
-export async function refreshLicense(jwt: string, opts: Pick<ActivateOptions, 'apiBase'>): Promise<string> {
-  const base = opts.apiBase ?? 'https://api.fallow.cloud/v1';
-  const res = await fetch(`${base}/license/refresh`, {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${jwt}`, 'Content-Type': 'application/json' },
-  });
-  if (!res.ok) throw new LicenseError(`Refresh failed: HTTP ${res.status}`, 'REFRESH_FAILED');
-  const data = await res.json() as { jwt: string };
-  return data.jwt;
-}
-
-/** Get the free-tier license status (no JWT required). */
-export function getFreeLicenseStatus(): LicenseStatus {
-  return {
-    tier: 'free',
-    seats: 1,
-    features: FREE_FEATURES,
-    isExpired: false,
-    isInWarningWindow: false,
-    isWatermarked: false,
-  };
-}

package/src/lsp/code-actions.ts

@@ -1,127 +0,0 @@
-import type { LspRange } from './code-lens.js';
-
-export interface LspTextEdit {
-  range: LspRange;
-  newText: string;
-}
-
-export interface LspWorkspaceEdit {
-  changes: Record<string, LspTextEdit[]>;
-}
-
-export interface CodeAction {
-  title: string;
-  kind: 'quickfix' | 'refactor';
-  diagnostics?: string[];
-  edit?: LspWorkspaceEdit;
-  isPreferred?: boolean;
-}
-
-export interface UnusedExportLocation {
-  exportName: string;
-  filePath: string;
-  uri: string;
-  line: number;         // 1-based
-  col: number;
-}
-
-export type ExportKeywordVariant = 'export' | 'export default' | 'export const' | 'export function' | 'export class' | 'export type' | 'export interface' | 'export enum';
-
-function detectExportVariant(sourceLine: string): { prefix: string; start: number } | null {
-  const variants = [
-    'export default ',
-    'export const ',
-    'export function ',
-    'export class ',
-    'export abstract class ',
-    'export interface ',
-    'export type ',
-    'export enum ',
-    'export ',
-  ];
-  const trimmed = sourceLine.trimStart();
-  const indent = sourceLine.length - trimmed.length;
-  for (const v of variants) {
-    if (trimmed.startsWith(v)) {
-      return { prefix: v, start: indent };
-    }
-  }
-  return null;
-}
-
-export function buildRemoveExportActions(
-  unusedExports: UnusedExportLocation[],
-  cursorLine: number,   // 0-based LSP
-  fileLines: string[],
-  maxActionsPerFile = 10,
-): CodeAction[] {
-  const actions: CodeAction[] = [];
-  const inRange = unusedExports.filter(e => e.line - 1 === cursorLine);
-  for (const ue of inRange.slice(0, maxActionsPerFile)) {
-    const sourceLine = fileLines[ue.line - 1] ?? '';
-    const variant = detectExportVariant(sourceLine);
-    if (!variant) continue;
-    const removeRange: LspRange = {
-      start: { line: ue.line - 1, character: variant.start },
-      end:   { line: ue.line - 1, character: variant.start + variant.prefix.length },
-    };
-    actions.push({
-      title: `Remove 'export' from '${ue.exportName}'`,
-      kind: 'quickfix',
-      isPreferred: true,
-      edit: {
-        changes: {
-          [ue.uri]: [{ range: removeRange, newText: '' }],
-        },
-      },
-    });
-  }
-  return actions;
-}
-
-export function buildSuppressActions(
-  unusedExports: UnusedExportLocation[],
-  cursorLine: number,   // 0-based LSP
-  fileLines: string[],
-): CodeAction[] {
-  const actions: CodeAction[] = [];
-  const inRange = unusedExports.filter(e => e.line - 1 === cursorLine);
-  for (const ue of inRange) {
-    const targetLine = ue.line - 1;  // 0-based
-    const sourceLine = fileLines[targetLine] ?? '';
-    const indent = sourceLine.length - sourceLine.trimStart().length;
-    const suppressComment = ' '.repeat(indent) + '// monograph-ignore\n';
-    const insertRange: LspRange = {
-      start: { line: targetLine, character: 0 },
-      end:   { line: targetLine, character: 0 },
-    };
-    actions.push({
-      title: `Suppress monograph warning for '${ue.exportName}'`,
-      kind: 'quickfix',
-      edit: {
-        changes: {
-          [ue.uri]: [{ range: insertRange, newText: suppressComment }],
-        },
-      },
-    });
-  }
-  return actions;
-}
-
-// ── Round 9: delete-file code actions ─────────────────────────────────────────
-
-export interface DeleteFileAction {
-  kind: 'deleteFile';
-  title: string;
-  filePath: string;
-  isPreferred: boolean;
-}
-
-export function buildDeleteFileActions(filePath: string): DeleteFileAction[] {
-  return [{
-    kind: 'deleteFile',
-    title: `Delete unused file: ${filePath.split('/').pop() ?? filePath}`,
-    filePath,
-    isPreferred: false,
-  }];
-}

package/src/lsp/code-lens.ts

@@ -1,56 +0,0 @@
-export interface LspPosition {
-  line: number;       // 0-based
-  character: number;
-}
-
-export interface LspRange {
-  start: LspPosition;
-  end: LspPosition;
-}
-
-export interface LspCommand {
-  title: string;
-  command: string;
-  arguments?: unknown[];
-}
-
-export interface MonographCodeLens {
-  range: LspRange;
-  command?: LspCommand;
-}
-
-export interface ExportUsage {
-  exportName: string;
-  line: number;      // 1-based
-  col: number;       // 1-based
-  referenceLocations: Array<{ uri: string; line: number; character: number }>;
-}
-
-export function buildCodeLenses(
-  usages: ExportUsage[],
-  documentUri: string,
-): MonographCodeLens[] {
-  return usages.map(usage => {
-    const lspLine = usage.line - 1;  // 1-based → 0-based
-    const lspCol  = usage.col  - 1;
-    const range: LspRange = {
-      start: { line: lspLine, character: lspCol },
-      end:   { line: lspLine, character: lspCol + usage.exportName.length },
-    };
-    const refCount = usage.referenceLocations.length;
-    if (refCount === 0) {
-      return {
-        range,
-        command: { title: '0 references', command: 'monograph.noop' },
-      };
-    }
-    return {
-      range,
-      command: {
-        title: `${refCount} reference${refCount === 1 ? '' : 's'}`,
-        command: 'editor.action.showReferences',
-        arguments: [documentUri, { line: lspLine, character: lspCol }, usage.referenceLocations],
-      },
-    };
-  });
-}

package/src/lsp/diagnostics-ext.ts

@@ -1,150 +0,0 @@
-import type { LspRange } from './code-lens.js';
-import type { MonographDiagnostic } from './diagnostics.js';
-
-// ── Unused-symbol diagnostics ────────────────────────────────────────────────
-
-export interface UnusedSymbolLocation {
-  uri: string;
-  line: number;         // 1-based
-  col: number;
-  name: string;
-  symbolKind: 'export' | 'type' | 'member' | 'file';
-}
-
-export function buildUnusedSymbolDiagnostics(
-  symbols: UnusedSymbolLocation[],
-): Map<string, MonographDiagnostic[]> {
-  const map = new Map<string, MonographDiagnostic[]>();
-  for (const sym of symbols) {
-    const range: LspRange = {
-      start: { line: sym.line - 1, character: sym.col - 1 },
-      end:   { line: sym.line - 1, character: sym.col - 1 + sym.name.length },
-    };
-    const messages: Record<UnusedSymbolLocation['symbolKind'], string> = {
-      export: `'${sym.name}' is exported but has no external consumers`,
-      type: `Type '${sym.name}' is exported but never imported elsewhere`,
-      member: `Class member '${sym.name}' is never used outside this class`,
-      file: `File '${sym.name}' has no importers and no entry-point role`,
-    };
-    const diag: MonographDiagnostic = {
-      range,
-      severity: 2,   // Warning
-      code: `monograph/unused-${sym.symbolKind}`,
-      source: 'monograph',
-      message: messages[sym.symbolKind],
-      tags: [1],     // Unnecessary
-    };
-    const arr = map.get(sym.uri) ?? [];
-    arr.push(diag);
-    map.set(sym.uri, arr);
-  }
-  return map;
-}
-
-// ── Structural diagnostics ────────────────────────────────────────────────────
-
-export interface CircularDepLocation {
-  uri: string;
-  importLine: number;   // 1-based, the import that closes the cycle
-  cycle: string[];      // module names in cycle
-}
-
-export interface BoundaryViolationLocation {
-  uri: string;
-  line: number;
-  fromZone: string;
-  toZone: string;
-  importedPath: string;
-}
-
-export function buildCircularDepDiagnostics(
-  cycles: CircularDepLocation[],
-): Map<string, MonographDiagnostic[]> {
-  const map = new Map<string, MonographDiagnostic[]>();
-  for (const cycle of cycles) {
-    const line0 = cycle.importLine - 1;
-    const range: LspRange = {
-      start: { line: line0, character: 0 },
-      end:   { line: line0, character: 65535 },
-    };
-    const diag: MonographDiagnostic = {
-      range,
-      severity: 2,   // Warning
-      code: 'monograph/circular-dep',
-      source: 'monograph',
-      message: `Circular dependency: ${cycle.cycle.join(' → ')}`,
-    };
-    const arr = map.get(cycle.uri) ?? [];
-    arr.push(diag);
-    map.set(cycle.uri, arr);
-  }
-  return map;
-}
-
-export function buildBoundaryViolationDiagnostics(
-  violations: BoundaryViolationLocation[],
-): Map<string, MonographDiagnostic[]> {
-  const map = new Map<string, MonographDiagnostic[]>();
-  for (const v of violations) {
-    const line0 = v.line - 1;
-    const range: LspRange = {
-      start: { line: line0, character: 0 },
-      end:   { line: line0, character: 65535 },
-    };
-    const diag: MonographDiagnostic = {
-      range,
-      severity: 1,   // Error
-      code: 'monograph/boundary-violation',
-      source: 'monograph',
-      message: `Boundary violation: zone '${v.fromZone}' cannot import from zone '${v.toZone}' (${v.importedPath})`,
-    };
-    const arr = map.get(v.uri) ?? [];
-    arr.push(diag);
-    map.set(v.uri, arr);
-  }
-  return map;
-}
-
-// ── Quality diagnostics ───────────────────────────────────────────────────────
-
-export interface ComplexityIssueLocation {
-  uri: string;
-  line: number;         // 1-based
-  functionName: string;
-  cyclomaticComplexity: number;
-  cognitiveComplexity?: number;
-  crapScore?: number;
-  severity: 'moderate' | 'high' | 'critical';
-}
-
-export function buildComplexityDiagnostics(
-  issues: ComplexityIssueLocation[],
-): Map<string, MonographDiagnostic[]> {
-  const map = new Map<string, MonographDiagnostic[]>();
-  for (const issue of issues) {
-    const line0 = issue.line - 1;
-    const range: LspRange = {
-      start: { line: line0, character: 0 },
-      end:   { line: line0, character: issue.functionName.length },
-    };
-    const lspSeverity: Record<ComplexityIssueLocation['severity'], 1 | 2 | 3> = {
-      moderate: 3,   // Information
-      high: 2,       // Warning
-      critical: 1,   // Error
-    };
-    const parts = [`CC=${issue.cyclomaticComplexity}`];
-    if (issue.cognitiveComplexity != null) parts.push(`cognitive=${issue.cognitiveComplexity}`);
-    if (issue.crapScore != null) parts.push(`CRAP=${issue.crapScore.toFixed(1)}`);
-    const diag: MonographDiagnostic = {
-      range,
-      severity: lspSeverity[issue.severity],
-      code: `monograph/complexity-${issue.severity}`,
-      source: 'monograph',
-      message: `'${issue.functionName}' has ${issue.severity} complexity (${parts.join(', ')})`,
-    };
-    const arr = map.get(issue.uri) ?? [];
-    arr.push(diag);
-    map.set(issue.uri, arr);
-  }
-  return map;
-}

package/src/lsp/diagnostics-push.ts

@@ -1,103 +0,0 @@
-// Granular LSP diagnostic push-functions for each finding category.
-
-export type DiagnosticSeverity = 'error' | 'warning' | 'information' | 'hint';
-
-export interface LspRange {
-  start: { line: number; character: number };
-  end: { line: number; character: number };
-}
-
-export interface LspDiagnosticEntry {
-  filePath: string;
-  range: LspRange;
-  message: string;
-  severity: DiagnosticSeverity;
-  code: string;
-  source: string;
-}
-
-export type DiagnosticMap = Map<string, LspDiagnosticEntry[]>;
-
-function singleLineDiag(
-  map: DiagnosticMap,
-  filePath: string,
-  line: number,
-  message: string,
-  code: string,
-  severity: DiagnosticSeverity = 'warning',
-): void {
-  if (!map.has(filePath)) map.set(filePath, []);
-  map.get(filePath)!.push({
-    filePath,
-    range: { start: { line, character: 0 }, end: { line, character: 9999 } },
-    message,
-    severity,
-    code,
-    source: 'monograph',
-  });
-}
-
-export interface UnusedExportFinding { filePath: string; line: number; symbol: string }
-export interface UnusedFileFinding { filePath: string }
-export interface UnresolvedImportFinding { filePath: string; line: number; specifier: string }
-export interface UnusedDepFinding { name: string; kind: 'unused' | 'unlisted' }
-export interface UnusedMemberFinding { filePath: string; line: number; className: string; member: string }
-export interface CircularDepFinding { files: string[] }
-export interface BoundaryViolFinding { fromFile: string; toFile: string; line: number; rule: string }
-export interface DupeExportFinding { filePath: string; line: number; symbol: string }
-export interface DuplicationFinding { filePath: string; startLine: number; endLine: number; groupId: number }
-export interface StaleSuppressionFinding { filePath: string; line: number; code: string }
-
-export function pushExportDiagnostics(map: DiagnosticMap, results: UnusedExportFinding[]): void {
-  for (const r of results)
-    singleLineDiag(map, r.filePath, r.line, `Unused export '${r.symbol}'`, 'unused-export');
-}
-
-export function pushFileDiagnostics(map: DiagnosticMap, results: UnusedFileFinding[]): void {
-  for (const r of results)
-    singleLineDiag(map, r.filePath, 0, 'File has no consumers and may be dead code', 'unused-file');
-}
-
-export function pushImportDiagnostics(map: DiagnosticMap, results: UnresolvedImportFinding[]): void {
-  for (const r of results)
-    singleLineDiag(map, r.filePath, r.line, `Cannot resolve import '${r.specifier}'`, 'unresolved-import', 'error');
-}
-
-export function pushDepDiagnostics(map: DiagnosticMap, results: UnusedDepFinding[]): void {
-  const msg = (r: UnusedDepFinding) =>
-    r.kind === 'unused' ? `Package '${r.name}' is listed but not imported` : `Package '${r.name}' is imported but not in dependencies`;
-  for (const r of results)
-    singleLineDiag(map, 'package.json', 0, msg(r), r.kind === 'unused' ? 'unused-dep' : 'unlisted-dep');
-}
-
-export function pushMemberDiagnostics(map: DiagnosticMap, results: UnusedMemberFinding[]): void {
-  for (const r of results)
-    singleLineDiag(map, r.filePath, r.line, `Unused member '${r.className}.${r.member}'`, 'unused-member');
-}
-
-export function pushCircularDepDiagnostics(map: DiagnosticMap, results: CircularDepFinding[]): void {
-  for (const r of results) {
-    const first = r.files[0];
-    if (first) singleLineDiag(map, first, 0, `Circular dependency involving ${r.files.length} files`, 'circular-dep', 'warning');
-  }
-}
-
-export function pushBoundaryViolationDiagnostics(map: DiagnosticMap, results: BoundaryViolFinding[]): void {
-  for (const r of results)
-    singleLineDiag(map, r.fromFile, r.line, `Boundary violation: imports from restricted zone (rule: ${r.rule})`, 'boundary-violation', 'error');
-}
-
-export function pushDuplicateExportDiagnostics(map: DiagnosticMap, results: DupeExportFinding[]): void {
-  for (const r of results)
-    singleLineDiag(map, r.filePath, r.line, `Duplicate export '${r.symbol}' — exported from multiple files`, 'duplicate-export');
-}
-
-export function pushDuplicationDiagnostics(map: DiagnosticMap, results: DuplicationFinding[]): void {
-  for (const r of results)
-    singleLineDiag(map, r.filePath, r.startLine, `Code duplication (group ${r.groupId}, lines ${r.startLine}-${r.endLine})`, 'duplication', 'information');
-}
-
-export function pushStaleSuppressionDiagnostics(map: DiagnosticMap, results: StaleSuppressionFinding[]): void {
-  for (const r of results)
-    singleLineDiag(map, r.filePath, r.line, `Stale suppression comment for '${r.code}' — no matching finding`, 'stale-suppression', 'hint');
-}

package/src/lsp/diagnostics.ts

@@ -1,98 +0,0 @@
-import type { LspRange } from './code-lens.js';
-
-export type DiagnosticSeverity = 1 | 2 | 3 | 4;  // Error | Warning | Information | Hint
-export type DiagnosticTag = 1 | 2;                // Unnecessary | Deprecated
-
-export interface RelatedInformation {
-  uri: string;
-  range: LspRange;
-  message: string;
-}
-
-export interface MonographDiagnostic {
-  range: LspRange;
-  severity: DiagnosticSeverity;
-  code: string;
-  source: string;
-  message: string;
-  tags?: DiagnosticTag[];
-  relatedInformation?: RelatedInformation[];
-}
-
-export interface DuplicateExportLocation {
-  uri: string;
-  line: number;   // 1-based
-  col: number;
-  exportName: string;
-}
-
-export interface DuplicateExportGroup {
-  name: string;
-  locations: DuplicateExportLocation[];
-}
-
-export interface StaleSuppressionInfo {
-  uri: string;
-  line: number;   // 1-based
-  description: string;
-}
-
-function makeRange(line: number, col: number, nameLength: number): LspRange {
-  return {
-    start: { line: line - 1, character: col - 1 },
-    end:   { line: line - 1, character: col - 1 + nameLength },
-  };
-}
-
-export function buildDuplicateExportDiagnostics(
-  groups: DuplicateExportGroup[],
-): Map<string, MonographDiagnostic[]> {
-  const map = new Map<string, MonographDiagnostic[]>();
-  for (const group of groups) {
-    for (const loc of group.locations) {
-      const related: RelatedInformation[] = group.locations
-        .filter(other => other !== loc)
-        .map(other => ({
-          uri: other.uri,
-          range: makeRange(other.line, other.col, group.name.length),
-          message: `Also exported as '${group.name}' here`,
-        }));
-      const diag: MonographDiagnostic = {
-        range: makeRange(loc.line, loc.col, group.name.length),
-        severity: 2,  // Warning
-        code: 'monograph/duplicate-export',
-        source: 'monograph',
-        message: `'${group.name}' is exported from ${group.locations.length} files`,
-        relatedInformation: related,
-      };
-      const arr = map.get(loc.uri) ?? [];
-      arr.push(diag);
-      map.set(loc.uri, arr);
-    }
-  }
-  return map;
-}
-
-export function buildStaleSuppressionDiagnostics(
-  suppressions: StaleSuppressionInfo[],
-): Map<string, MonographDiagnostic[]> {
-  const map = new Map<string, MonographDiagnostic[]>();
-  for (const s of suppressions) {
-    const range: LspRange = {
-      start: { line: s.line - 1, character: 0 },
-      end:   { line: s.line - 1, character: 65535 },
-    };
-    const diag: MonographDiagnostic = {
-      range,
-      severity: 4,  // Hint
-      code: 'monograph/stale-suppression',
-      source: 'monograph',
-      message: s.description,
-      tags: [1],  // Unnecessary
-    };
-    const arr = map.get(s.uri) ?? [];
-    arr.push(diag);
-    map.set(s.uri, arr);
-  }
-  return map;
-}