@3fn/core 13.0.0 → 14.1.0

package/src/tools/release/publishers/NpmPublisher.ts

@@ -1,196 +0,0 @@
-/**
- * npm Publisher for Release Tool
- *
- * Handles npm registry publishing, validation, and rollback.
- * Extracted from src/release/publishing/NpmPublisher.ts.
- * Gated behind npmPublishEnabled config flag.
- */
-
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import { PackagePublish, PublishResult } from '../types';
-
-export interface NpmConfig {
-  registry?: string;
-  token?: string;
-  timeout?: number;
-  maxRetries?: number;
-  retryDelay?: number;
-  dryRun?: boolean;
-  otp?: string;
-}
-
-export interface NpmAuthStatus {
-  authenticated: boolean;
-  username?: string;
-  email?: string;
-  registry: string;
-}
-
-export interface PackageInfo {
-  name: string;
-  version: string;
-  exists: boolean;
-  publishedVersions: string[];
-}
-
-export class NpmPublisher {
-  private config: NpmConfig;
-  private authenticated: boolean = false;
-
-  constructor(config: NpmConfig = {}) {
-    this.config = {
-      registry: 'https://registry.npmjs.org/',
-      timeout: 60000, maxRetries: 3, retryDelay: 2000, dryRun: false,
-      ...config,
-    };
-  }
-
-  async validateAuthentication(): Promise<NpmAuthStatus> {
-    try {
-      const whoami = this.execNpmCommand('whoami', { throwOnError: false });
-      if (whoami.success && whoami.stdout) {
-        const username = whoami.stdout.trim();
-        const profile = this.execNpmCommand('profile get --json', { throwOnError: false });
-        let email: string | undefined;
-        if (profile.success && profile.stdout) {
-          try { email = JSON.parse(profile.stdout).email; } catch { /* ignore */ }
-        }
-        this.authenticated = true;
-        return { authenticated: true, username, email, registry: this.config.registry || 'https://registry.npmjs.org/' };
-      }
-      this.authenticated = false;
-      return { authenticated: false, registry: this.config.registry || 'https://registry.npmjs.org/' };
-    } catch (error) {
-      this.authenticated = false;
-      throw new Error(`npm authentication validation failed: ${this.getErrorMessage(error)}`);
-    }
-  }
-
-  async packageVersionExists(packageName: string, version: string): Promise<boolean> {
-    try {
-      const result = this.execNpmCommand(`view ${packageName}@${version} version --json`, { throwOnError: false });
-      return result.success && result.stdout.trim() !== '';
-    } catch { return false; }
-  }
-
-  async getPackageInfo(packageName: string): Promise<PackageInfo> {
-    try {
-      const result = this.execNpmCommand(`view ${packageName} versions --json`, { throwOnError: false });
-      if (result.success && result.stdout) {
-        try {
-          const versions = JSON.parse(result.stdout);
-          const publishedVersions = Array.isArray(versions) ? versions : [versions];
-          return { name: packageName, version: publishedVersions[publishedVersions.length - 1] || '0.0.0', exists: publishedVersions.length > 0, publishedVersions };
-        } catch { /* fall through */ }
-      }
-      return { name: packageName, version: '0.0.0', exists: false, publishedVersions: [] };
-    } catch (error) {
-      throw new Error(`Failed to get package info: ${this.getErrorMessage(error)}`);
-    }
-  }
-
-  async validatePackage(pkg: PackagePublish): Promise<{ valid: boolean; errors: string[] }> {
-    const errors: string[] = [];
-    const packageJsonPath = path.join(pkg.path, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) {
-      errors.push(`package.json not found at ${packageJsonPath}`);
-      return { valid: false, errors };
-    }
-    try {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-      if (packageJson.name !== pkg.name) errors.push(`Package name mismatch: expected ${pkg.name}, got ${packageJson.name}`);
-      if (packageJson.version !== pkg.version) errors.push(`Version mismatch: expected ${pkg.version}, got ${packageJson.version}`);
-      if (!packageJson.name) errors.push('Package name is required');
-      if (!packageJson.version) errors.push('Package version is required');
-      if (packageJson.version && !this.isValidSemver(packageJson.version)) errors.push(`Invalid semver version: ${packageJson.version}`);
-    } catch (error) {
-      errors.push(`Failed to read package.json: ${this.getErrorMessage(error)}`);
-    }
-    return { valid: errors.length === 0, errors };
-  }
-
-  async publishPackage(pkg: PackagePublish): Promise<PublishResult> {
-    try {
-      if (!this.authenticated) {
-        const authStatus = await this.validateAuthentication();
-        if (!authStatus.authenticated) throw new Error('Not authenticated with npm registry. Run "npm login" first.');
-      }
-      const validation = await this.validatePackage(pkg);
-      if (!validation.valid) throw new Error(`Package validation failed: ${validation.errors.join(', ')}`);
-      const versionExists = await this.packageVersionExists(pkg.name, pkg.version);
-      if (versionExists) throw new Error(`Package ${pkg.name}@${pkg.version} already exists in registry`);
-      return await this.publishWithRetry(pkg);
-    } catch (error) {
-      return { success: false, packageName: pkg.name, version: pkg.version, error: this.getErrorMessage(error) };
-    }
-  }
-
-  async publishPackages(packages: PackagePublish[]): Promise<PublishResult[]> {
-    const results: PublishResult[] = [];
-    for (const pkg of packages) {
-      const result = await this.publishPackage(pkg);
-      results.push(result);
-      if (!result.success && !this.config.dryRun) {
-        for (const remaining of packages.slice(packages.indexOf(pkg) + 1)) {
-          results.push({ success: false, packageName: remaining.name, version: remaining.version, error: 'Publishing stopped due to previous failure' });
-        }
-        break;
-      }
-    }
-    return results;
-  }
-
-  async unpublishPackage(packageName: string, version: string): Promise<boolean> {
-    try {
-      const exists = await this.packageVersionExists(packageName, version);
-      if (!exists) throw new Error(`Package ${packageName}@${version} does not exist in registry`);
-      const result = this.execNpmCommand(`unpublish ${packageName}@${version} --force`, { throwOnError: true });
-      return result.success;
-    } catch (error) {
-      throw new Error(`Failed to unpublish package: ${this.getErrorMessage(error)}`);
-    }
-  }
-
-  private async publishWithRetry(pkg: PackagePublish, attempt: number = 1): Promise<PublishResult> {
-    try {
-      let command = `publish ${pkg.path}`;
-      if (pkg.access) command += ` --access ${pkg.access}`;
-      if (pkg.registry) command += ` --registry ${pkg.registry}`;
-      if (this.config.otp) command += ` --otp ${this.config.otp}`;
-      if (this.config.dryRun) command += ` --dry-run`;
-      this.execNpmCommand(command, { throwOnError: true });
-      return { success: true, packageName: pkg.name, version: pkg.version, url: `${pkg.registry || this.config.registry}package/${pkg.name}` };
-    } catch (error) {
-      if (attempt < (this.config.maxRetries || 3)) {
-        await new Promise((r) => setTimeout(r, this.config.retryDelay || 2000));
-        return this.publishWithRetry(pkg, attempt + 1);
-      }
-      throw error;
-    }
-  }
-
-  private execNpmCommand(command: string, options: { throwOnError?: boolean } = {}): { success: boolean; stdout: string; stderr: string } {
-    try {
-      let fullCommand = `npm ${command}`;
-      if (this.config.registry && !command.includes('--registry')) fullCommand += ` --registry ${this.config.registry}`;
-      const stdout = execSync(fullCommand, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: this.config.timeout });
-      return { success: true, stdout: stdout || '', stderr: '' };
-    } catch (error: any) {
-      if (options.throwOnError) throw new Error(`npm command failed: ${error.stderr?.toString() || error.message}`);
-      return { success: false, stdout: error.stdout?.toString() || '', stderr: error.stderr?.toString() || '' };
-    }
-  }
-
-  private isValidSemver(version: string): boolean {
-    return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(version);
-  }
-
-  private getErrorMessage(error: unknown): string {
-    if (error instanceof Error) return error.message;
-    if (typeof error === 'string') return error;
-    if (error && typeof error === 'object' && 'message' in error) return String((error as any).message);
-    return 'Unknown error occurred';
-  }
-}

package/src/tools/release/release-config.json

@@ -1,5 +0,0 @@
-{
-  "npmPublishEnabled": false,
-  "outputDir": "docs/releases",
-  "repoUrl": "https://github.com/3fn/DesignerPunk"
-}

package/src/tools/release/types/index.ts

@@ -1,282 +0,0 @@
-/**
- * Shared types for the release tool pipeline.
- *
- * Organized into three sections:
- * 1. Pipeline types — the new system's domain model (design.md interfaces)
- * 2. Calculator types — shapes consumed by the extracted VersionCalculator
- * 3. Publisher types — shapes consumed by the extracted publishers
- */
-
-// ============================================================
-// 1. PIPELINE TYPES — new release tool domain model
-// ============================================================
-
-/** Git tag information from TagResolver */
-export interface TagInfo {
-  tag: string;
-  commit: string;
-  date: string;
-}
-
-/** Parsed summary document from SummaryScanner */
-export interface SummaryDoc {
-  path: string;
-  specName: string;
-  taskNumber: number;
-  raw: string;
-}
-
-/** Extracted change from a single summary doc (ChangeExtractor output) */
-export interface ExtractedChange {
-  specName: string;
-  taskTitle: string;
-  taskType: string;
-  whatWasDone: string;
-  whyItMatters: string;
-  keyChanges: string[];
-  impact: string[];
-  deliverables?: DeliverableEntry[];
-}
-
-/** Structured deliverable from optional ## Deliverables section */
-export interface DeliverableEntry {
-  priority: '🔴' | '🟡' | '🔵';
-  type: string;
-  description: string;
-}
-
-/** Priority tier for change classification */
-export type Priority = 'breaking' | 'prominent' | 'context';
-
-/** Classified change (ChangeClassifier output) */
-export interface ClassifiedChange {
-  change: ExtractedChange;
-  priority: Priority;
-  deliverableType: string;
-}
-
-/** Pipeline-level version recommendation */
-export interface PipelineRecommendation {
-  currentVersion: string;
-  recommendedVersion: string;
-  bumpType: 'major' | 'minor' | 'patch' | 'none';
-  rationale: string;
-  confidence: number;
-  changes: ClassifiedChange[];
-}
-
-/** Rendered release notes (NotesRenderer output) */
-export interface RenderedNotes {
-  public: string;
-  internal: string;
-  json: ReleaseData;
-}
-
-/** Structured intermediate for testability */
-export interface ReleaseData {
-  version: string;
-  previousVersion: string;
-  date: string;
-  changes: ClassifiedChange[];
-  recommendation: PipelineRecommendation;
-}
-
-/** Release tool configuration */
-export interface ReleaseConfig {
-  npmPublishEnabled: boolean;
-  repoUrl: string;
-  outputDir: string;
-}
-
-// ============================================================
-// 2. CALCULATOR TYPES — extracted VersionCalculator shapes
-// ============================================================
-
-export interface BreakingChange {
-  id: string;
-  title: string;
-  description: string;
-  affectedAPIs: string[];
-  migrationGuidance?: string;
-  source: string;
-  severity: 'low' | 'medium' | 'high' | 'critical';
-}
-
-export interface Feature {
-  id: string;
-  title: string;
-  description: string;
-  benefits: string[];
-  requirements: string[];
-  artifacts: string[];
-  source: string;
-  category: string;
-}
-
-export interface BugFix {
-  id: string;
-  title: string;
-  description: string;
-  issueReference?: string;
-  affectedComponents: string[];
-  source: string;
-  severity: 'low' | 'medium' | 'high' | 'critical';
-}
-
-export interface Improvement {
-  id: string;
-  title: string;
-  description: string;
-  type: 'performance' | 'usability' | 'maintainability' | 'security' | 'accessibility' | 'other';
-  impact: 'low' | 'medium' | 'high';
-  source: string;
-}
-
-export interface DocumentationChange {
-  id: string;
-  title: string;
-  description: string;
-  type: 'readme' | 'api-docs' | 'examples' | 'comments' | 'other';
-  source: string;
-}
-
-export interface ExtractedChanges {
-  breakingChanges: BreakingChange[];
-  newFeatures: Feature[];
-  bugFixes: BugFix[];
-  improvements: Improvement[];
-  documentation: DocumentationChange[];
-  metadata: ExtractionMetadata;
-}
-
-export interface ExtractionMetadata {
-  documentsAnalyzed: number;
-  extractionConfidence: number;
-  ambiguousItems: string[];
-  filteredItems: string[];
-}
-
-export interface VersionRecommendation {
-  currentVersion: string;
-  recommendedVersion: string;
-  bumpType: 'major' | 'minor' | 'patch' | 'none';
-  rationale: string;
-  confidence: number;
-  evidence: ChangeEvidence[];
-  preReleaseInfo?: PreReleaseInfo;
-}
-
-export interface ChangeEvidence {
-  type: 'breaking' | 'feature' | 'fix' | 'improvement';
-  description: string;
-  source: string;
-  impact: 'high' | 'medium' | 'low';
-  count?: number;
-}
-
-export interface PreReleaseInfo {
-  isPreRelease: boolean;
-  preReleaseType?: 'alpha' | 'beta' | 'rc';
-  preReleaseNumber?: number;
-  canPromote?: boolean;
-  nextPreRelease?: string;
-}
-
-export interface ValidationResult {
-  valid: boolean;
-  errors: string[];
-  warnings: string[];
-}
-
-export interface ParsedVersion {
-  major: number;
-  minor: number;
-  patch: number;
-  preRelease: string | null;
-  build: string | null;
-  raw: string;
-}
-
-// ============================================================
-// 3. PUBLISHER TYPES — extracted publisher shapes
-// ============================================================
-
-export interface GitHubRelease {
-  tagName: string;
-  name: string;
-  body: string;
-  draft: boolean;
-  prerelease: boolean;
-  artifacts: Artifact[];
-}
-
-export interface GitTag {
-  name: string;
-  message: string;
-  commit: string;
-}
-
-export interface Artifact {
-  name: string;
-  path: string;
-  contentType: string;
-  size: number;
-}
-
-export interface ReleaseResult {
-  success: boolean;
-  version: string;
-  releasedPackages: string[];
-  githubReleaseUrl?: string;
-  npmPackageUrls: string[];
-  duration: number;
-  errors: ReleaseError[];
-  releasedAt: Date;
-}
-
-export interface ReleaseError {
-  code: string;
-  message: string;
-  severity: 'error' | 'warning';
-  package?: string;
-  step?: string;
-  stackTrace?: string;
-}
-
-export interface TagResult {
-  success: boolean;
-  tagName: string;
-  error?: string;
-}
-
-export interface UploadResult {
-  success: boolean;
-  artifactName: string;
-  url?: string;
-  error?: string;
-}
-
-export interface RepositoryInfo {
-  owner: string;
-  name: string;
-  fullName: string;
-  defaultBranch: string;
-  private: boolean;
-  url: string;
-}
-
-export interface PackagePublish {
-  name: string;
-  version: string;
-  path: string;
-  registry: string;
-  access: 'public' | 'restricted';
-}
-
-export interface PublishResult {
-  success: boolean;
-  packageName: string;
-  version: string;
-  url?: string;
-  error?: string;
-}

package/src/tools/release/validators/SemanticVersionValidator.ts

@@ -1,67 +0,0 @@
-/**
- * Semantic Version Validator for Release Tool
- *
- * Lightweight validation layer on top of VersionCalculator.
- * The original SemanticVersionValidator (330 lines) was coupled to
- * SemanticVersioningRules config and VersionBump types from the old system.
- * This version delegates to VersionCalculator for parsing and validation,
- * adding only the format and progression checks the pipeline needs.
- */
-
-import { VersionCalculator } from '../pipeline/VersionCalculator';
-import { ValidationResult } from '../types';
-
-export class SemanticVersionValidator {
-  private calculator: VersionCalculator;
-
-  constructor(calculator?: VersionCalculator) {
-    this.calculator = calculator || new VersionCalculator();
-  }
-
-  validateFormat(version: string): ValidationResult {
-    const errors: string[] = [];
-    const warnings: string[] = [];
-
-    try {
-      this.calculator.parseVersion(version);
-    } catch {
-      errors.push(`Version '${version}' does not follow semantic versioning specification`);
-    }
-
-    return { valid: errors.length === 0, errors, warnings };
-  }
-
-  validateProgression(
-    from: string,
-    to: string,
-    bumpType: 'major' | 'minor' | 'patch' | 'none',
-  ): ValidationResult {
-    const errors: string[] = [];
-    const warnings: string[] = [];
-
-    const fromValidation = this.validateFormat(from);
-    const toValidation = this.validateFormat(to);
-
-    if (!fromValidation.valid) {
-      errors.push(...fromValidation.errors);
-      return { valid: false, errors, warnings };
-    }
-    if (!toValidation.valid) {
-      errors.push(...toValidation.errors);
-      return { valid: false, errors, warnings };
-    }
-
-    // Delegate to VersionCalculator's existing validation
-    const recommendation = {
-      currentVersion: from,
-      recommendedVersion: to,
-      bumpType,
-      rationale: '',
-      confidence: 1,
-      evidence: [],
-    };
-
-    const result = this.calculator.validateSemanticVersioning(recommendation);
-    return result;
-  }
-}