gitspace 0.2.0-rc.20 → 0.2.0-rc.21

package/src/utils/logger.ts

@@ -1,127 +0,0 @@
-/**
- * Logging utilities with chalk for colored output
- */
-
-import chalk from 'chalk';
-
-/**
- * Log levels
- */
-export type LogLevel = 'info' | 'success' | 'warning' | 'error' | 'debug';
-
-/**
- * Logger instance
- */
-class Logger {
-  private debugMode: boolean = false;
-
-  /**
-   * Enable or disable debug mode
-   */
-  setDebugMode(enabled: boolean): void {
-    this.debugMode = enabled;
-  }
-
-  /**
-   * Log an info message
-   */
-  info(message: string): void {
-    console.log(chalk.blue('ℹ'), message);
-  }
-
-  /**
-   * Log a success message
-   */
-  success(message: string): void {
-    console.log(chalk.green('✓'), message);
-  }
-
-  /**
-   * Log a warning message
-   */
-  warning(message: string): void {
-    console.log(chalk.yellow('⚠'), message);
-  }
-
-  /**
-   * Log an error message
-   */
-  error(message: string): void {
-    console.error(chalk.red('✗'), message);
-  }
-
-  /**
-   * Log a debug message (only if debug mode is enabled)
-   */
-  debug(message: string): void {
-    if (this.debugMode) {
-      console.log(chalk.gray('DEBUG:'), message);
-    }
-  }
-
-  /**
-   * Log a message without any prefix
-   */
-  log(message: string): void {
-    console.log(message);
-  }
-
-  /**
-   * Log a dim/muted message
-   */
-  dim(message: string): void {
-    console.log(chalk.dim(message));
-  }
-
-  /**
-   * Log a bold message
-   */
-  bold(message: string): void {
-    console.log(chalk.bold(message));
-  }
-
-  /**
-   * Create a spinner-like loading message
-   */
-  loading(message: string): () => void {
-    process.stdout.write(chalk.blue('⠋') + ' ' + message);
-
-    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let i = 0;
-
-    const interval = setInterval(() => {
-      process.stdout.write('\r' + chalk.blue(frames[i]) + ' ' + message);
-      i = (i + 1) % frames.length;
-    }, 80);
-
-    // Return a function to stop the spinner
-    return () => {
-      clearInterval(interval);
-      process.stdout.write('\r' + ' '.repeat(message.length + 2) + '\r');
-    };
-  }
-
-  /**
-   * Format a command for display
-   */
-  command(cmd: string): string {
-    return chalk.cyan(cmd);
-  }
-
-  /**
-   * Format a path for display
-   */
-  path(path: string): string {
-    return chalk.magenta(path);
-  }
-
-  /**
-   * Format a highlight for display
-   */
-  highlight(text: string): string {
-    return chalk.yellow(text);
-  }
-}
-
-// Export singleton instance
-export const logger = new Logger();

package/src/utils/markdown.ts

@@ -1,254 +0,0 @@
-/**
- * Markdown generation for Linear issues
- * Generates markdown files in the specified template format
- */
-
-import { writeFileSync } from 'fs'
-import { join, extname } from 'path'
-import type { LinearIssue as Issue, LinearAttachment } from '../types/workspace'
-import { logger } from './logger.js'
-
-/**
- * Convert a string to kebab-case for branch names
- */
-function toKebabCase(str: string, maxLength = 60): string {
-	const kebab = str
-		.toLowerCase()
-		.replace(/[^\w\s-]/g, '') // Remove special chars
-		.replace(/\s+/g, '-') // Replace spaces with dashes
-		.replace(/-+/g, '-') // Collapse multiple dashes
-		.replace(/^-|-$/g, '') // Remove leading/trailing dashes
-
-	// Truncate to max length at word boundary
-	if (kebab.length <= maxLength) {
-		return kebab
-	}
-
-	const truncated = kebab.substring(0, maxLength)
-	const lastDash = truncated.lastIndexOf('-')
-
-	return lastDash > 0 ? truncated.substring(0, lastDash) : truncated
-}
-
-/**
- * Clean markdown text to plaintext while preserving structure
- * Keeps lists and code fences readable
- */
-function cleanMarkdown(text: string): string {
-	// For now, just return the text as-is
-	// More sophisticated markdown-to-plaintext conversion can be added later
-	return text.trim()
-}
-
-/**
- * Download an image from a URL and save it to disk
- * Supports authenticated Linear image downloads
- */
-async function downloadImage(
-	url: string,
-	filepath: string,
-	linearApiKey?: string
-): Promise<void> {
-	try {
-		// Check if this is a Linear upload URL that requires authentication
-		const isLinearUpload = url.includes('uploads.linear.app')
-
-		// Prepare fetch options
-		const fetchOptions: RequestInit = {}
-
-		if (isLinearUpload && linearApiKey) {
-			// Linear API keys (lin_api_...) don't use Bearer prefix
-			// Only OAuth tokens use Bearer prefix
-			const authHeader = linearApiKey.startsWith('lin_api_')
-				? linearApiKey
-				: `Bearer ${linearApiKey}`
-
-			fetchOptions.headers = {
-				Authorization: authHeader,
-			}
-		}
-
-		const response = await fetch(url, fetchOptions)
-
-		if (!response.ok) {
-			throw new Error(
-				`Failed to download image: ${response.status} ${response.statusText}`
-			)
-		}
-
-		const arrayBuffer = await response.arrayBuffer()
-		const buffer = Buffer.from(arrayBuffer)
-
-		writeFileSync(filepath, buffer)
-		logger.debug(`Downloaded image: ${url} -> ${filepath}`)
-	} catch (error) {
-		logger.warning(
-			`Failed to download image from ${url}: ${
-				error instanceof Error ? error.message : 'Unknown error'
-			}`
-		)
-		throw error
-	}
-}
-
-/**
- * Get file extension from URL or default to .png
- */
-function getExtensionFromUrl(url: string): string {
-	try {
-		const urlObj = new URL(url)
-		const pathname = urlObj.pathname
-		const ext = extname(pathname)
-
-		// Common image extensions
-		if (
-			['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp'].includes(
-				ext.toLowerCase()
-			)
-		) {
-			return ext.toLowerCase()
-		}
-	} catch {
-		// Invalid URL, fall through to default
-	}
-
-	return '.png'
-}
-
-/**
- * Download and localize images in markdown and from attachments
- * Replaces image URLs with local file paths
- */
-async function downloadAndLocalizeImages(
-	description: string,
-	attachments: LinearAttachment[],
-	promptDir: string,
-	linearApiKey?: string
-): Promise<string> {
-	let localizedDescription = description
-	let imageCounter = 1
-
-	// Regular expression to match markdown images: ![alt](url)
-	const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g
-
-	// Extract all image URLs from markdown
-	const imageMatches = Array.from(description.matchAll(imageRegex))
-
-	// Download images from markdown description
-	for (const match of imageMatches) {
-		const [fullMatch, altText, imageUrl] = match
-
-		try {
-			const ext = getExtensionFromUrl(imageUrl)
-			const filename = `image-${imageCounter}${ext}`
-			const filepath = join(promptDir, filename)
-
-			await downloadImage(imageUrl, filepath, linearApiKey)
-
-			// Replace URL with local path in markdown
-			localizedDescription = localizedDescription.replace(
-				fullMatch,
-				`![${altText}](./${filename})`
-			)
-
-			imageCounter++
-		} catch (error) {
-			logger.warning(`Skipping image: ${imageUrl}`)
-			// Keep original URL if download fails
-		}
-	}
-
-	// Download images from Linear attachments (if they're image URLs)
-	for (const attachment of attachments) {
-		// Check if attachment is an image based on URL
-		const isImage = /\.(png|jpg|jpeg|gif|svg|webp)$/i.test(attachment.url)
-
-		if (isImage) {
-			try {
-				const ext = getExtensionFromUrl(attachment.url)
-				const filename = `attachment-${imageCounter}${ext}`
-				const filepath = join(promptDir, filename)
-
-				await downloadImage(attachment.url, filepath, linearApiKey)
-
-				// Add attachment to markdown if not already present
-				const attachmentTitle = attachment.title || `Attachment ${imageCounter}`
-				const attachmentMarkdown = `\n\n![${attachmentTitle}](./${filename})`
-
-				// Only add if this URL isn't already in the description
-				if (!description.includes(attachment.url)) {
-					localizedDescription += attachmentMarkdown
-				}
-
-				imageCounter++
-			} catch (error) {
-				logger.warning(`Skipping attachment: ${attachment.url}`)
-			}
-		}
-	}
-
-	return localizedDescription
-}
-
-/**
- * Generate markdown content for an issue
- * Follows the exact template format from the specification
- *
- * @param issue - The issue to generate markdown for
- * @param promptDir - Directory where images will be saved (optional, if provided downloads images)
- * @param linearApiKey - Linear API key for authenticated image downloads (optional)
- * @returns Markdown formatted string
- */
-export async function generateMarkdown(
-	issue: Issue,
-	promptDir?: string,
-	linearApiKey?: string
-): Promise<string> {
-	const assignee = await issue.assignee
-	const state = await issue.state
-
-	const assigneeName = assignee?.name || 'unassigned'
-
-	let description = issue.description || 'No description provided.'
-
-	// Download and localize images if promptDir is provided
-	if (promptDir && issue.description) {
-		try {
-			// Fetch attachments (lazy-loaded - only called when needed)
-			const attachments = await issue.attachments()
-
-			description = await downloadAndLocalizeImages(
-				issue.description,
-				attachments,
-				promptDir,
-				linearApiKey
-			)
-		} catch (error) {
-			logger.warning('Failed to download some images, using original URLs')
-		}
-	}
-
-	const fullDescription = cleanMarkdown(description)
-	const branchName = `${issue.identifier}-${toKebabCase(issue.title)}`
-
-	return `# ${issue.identifier}: ${issue.title}
-
-**linear url:** ${issue.url}
-**assignee:** ${assigneeName}
-**state:** ${state?.name ?? 'Unknown'}
-
-## description
-
-${fullDescription}
-
-## acceptance criteria (fill in)
-
-- [ ] criterion 1
-- [ ] criterion 2
-
-## implementation notes (auto-generated)
-
-- branch name: \`${branchName}\`
-- source issue id: \`${issue.id}\`
-`
-}

package/src/utils/normalize-env-key.ts

@@ -1,13 +0,0 @@
-export function normalizeEnvKey(key: string): string {
-  return key
-    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
-    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-    .replace(/[^A-Za-z0-9]+/g, '_')
-    .replace(/_+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    .toUpperCase();
-}
-
-export function isShellEnvKey(key: string): boolean {
-  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
-}

package/src/utils/onboarding.ts

@@ -1,279 +0,0 @@
-/**
- * Onboarding step execution engine
- * Runs interactive onboarding steps from bundle manifests
- */
-
-import { logger } from './logger.js';
-import { promptInput, promptConfirm, promptPassword } from './prompts.js';
-import { checkCommandExists } from './deps.js';
-import type {
-  OnboardingStep,
-  OnboardingResult,
-  ConfirmStepResult,
-  ConfirmStep,
-  SecretStep,
-  InputStep,
-} from '../types/bundle.js';
-
-/**
- * Marker value returned when user chooses to keep an existing secret
- */
-export const KEEP_EXISTING_SECRET = '__KEEP_EXISTING_SECRET__';
-
-/**
- * Marker value returned when an optional confirm step is skipped.
- */
-const SKIP_OPTIONAL_CONFIRM = '__SKIP_OPTIONAL_CONFIRM__';
-
-/**
- * Options for running onboarding
- */
-export interface OnboardingOptions {
-  /** Previous values from a prior onboarding run (for refresh) */
-  previousValues?: Record<string, string>;
-  /** Previous secret keys that exist in keychain */
-  previousSecretKeys?: string[];
-  /** Title to show (default: "Project Onboarding") */
-  title?: string;
-  /** Whether this is a refresh (shows different messaging) */
-  isRefresh?: boolean;
-}
-
-/**
- * Execute all onboarding steps
- */
-export async function runOnboarding(
-  steps: OnboardingStep[],
-  options: OnboardingOptions = {}
-): Promise<OnboardingResult> {
-  const result: OnboardingResult = {
-    inputValues: {},
-    secretValues: {},
-    confirmResults: {},
-    completed: false,
-  };
-
-  const title = options.title || 'Project Onboarding';
-  const refreshNote = options.isRefresh ? ' (refreshing - press Enter to keep existing values)' : '';
-  logger.bold(`\n=== ${title}${refreshNote} ===\n`);
-
-  for (let i = 0; i < steps.length; i++) {
-    const step = steps[i];
-    const stepNumber = i + 1;
-    const totalSteps = steps.length;
-
-    logger.log(`\n[${stepNumber}/${totalSteps}] ${step.title}`);
-    logger.dim(step.description);
-    logger.log('');
-
-    const stepResult = await executeStep(step, options);
-
-    if (stepResult === null) {
-      // User cancelled
-      result.cancelledAt = step.id;
-      logger.warning('\nOnboarding cancelled');
-      return result;
-    }
-
-    // Store values and metadata by step type
-    if (step.type === 'secret') {
-      result.secretValues[step.configKey] = stepResult;
-    } else if (step.type === 'input') {
-      result.inputValues[step.configKey] = stepResult;
-    } else if (step.type === 'confirm') {
-      const confirmResult: ConfirmStepResult = {
-        status: stepResult === SKIP_OPTIONAL_CONFIRM ? 'skipped' : 'passed',
-        checkCommand: step.checkCommand,
-      };
-      result.confirmResults[step.id] = confirmResult;
-    }
-  }
-
-  result.completed = true;
-  logger.success('\nOnboarding complete!');
-  return result;
-}
-
-/**
- * Execute a single onboarding step
- * Returns collected value or null if cancelled
- */
-async function executeStep(step: OnboardingStep, options: OnboardingOptions): Promise<string | null> {
-  switch (step.type) {
-    case 'info':
-      return executeInfoStep();
-    case 'confirm':
-      return executeConfirmStep(step);
-    case 'secret':
-      return executeSecretStep(step, options);
-    case 'input':
-      return executeInputStep(step, options);
-    default:
-      logger.warning('Unknown step type, skipping');
-      return '';
-  }
-}
-
-/**
- * Execute info step - just wait for acknowledgment
- */
-async function executeInfoStep(): Promise<string | null> {
-  const confirmed = await promptConfirm('Press Enter to continue...', true);
-  return confirmed ? '' : null;
-}
-
-/**
- * Execute confirm step - optionally check command
- */
-async function executeConfirmStep(step: ConfirmStep): Promise<string | null> {
-  // Check if command exists (if specified)
-  if (step.checkCommand) {
-    const exists = await checkCommandExists(step.checkCommand);
-
-    if (exists) {
-      logger.success(`✓ ${step.checkCommand} is installed`);
-      return '';
-    }
-
-    logger.warning(`✗ ${step.checkCommand} not found in PATH`);
-
-    if (step.installUrl) {
-      logger.log(`\nInstall instructions: ${step.installUrl}`);
-    }
-
-    // Ask user to confirm they've installed it
-    const prompt = step.confirmPrompt || `Have you installed ${step.checkCommand}?`;
-
-    while (true) {
-      const confirmed = await promptConfirm(prompt, false);
-
-      if (!confirmed) {
-        // User said no or cancelled
-        if (step.required !== false) {
-          logger.warning('This step is required. Please install and try again.');
-          continue;
-        }
-        // Optional step - skip it
-        logger.dim('Skipping optional step');
-        return SKIP_OPTIONAL_CONFIRM;
-      }
-
-      // Re-check if they say yes
-      const nowExists = await checkCommandExists(step.checkCommand);
-      if (nowExists) {
-        logger.success(`✓ ${step.checkCommand} is now available`);
-        return '';
-      }
-
-      logger.warning(`${step.checkCommand} still not found. Please ensure it's in your PATH.`);
-    }
-  }
-
-  // No command check, just confirm
-  const prompt = step.confirmPrompt || 'Continue?';
-  const confirmed = await promptConfirm(prompt, true);
-  if (!confirmed && step.required === false) {
-    // Optional step - skip it instead of cancelling
-    logger.dim('Skipping optional step');
-    return SKIP_OPTIONAL_CONFIRM;
-  }
-  return confirmed ? '' : null;
-}
-
-/**
- * Execute secret step - collect masked input
- */
-async function executeSecretStep(step: SecretStep, options: OnboardingOptions): Promise<string | null> {
-  const validator = step.validationPattern
-    ? createValidator(step.validationPattern, step.validationMessage)
-    : undefined;
-
-  // Check if we have an existing secret for this key
-  const hasExistingSecret = options.previousSecretKeys?.includes(step.configKey);
-
-  if (hasExistingSecret && options.isRefresh) {
-    logger.dim('  (existing secret found)');
-    const keepExisting = await promptConfirm('Keep existing secret? (Enter to keep, n to change)', true);
-    if (keepExisting) {
-      // Return special marker that means "keep existing"
-      return KEEP_EXISTING_SECRET;
-    }
-  }
-
-  while (true) {
-    const value = await promptPassword(`Enter ${step.title}:`);
-
-    if (value === null) {
-      return null; // Cancelled
-    }
-
-    if (!value && step.required !== false) {
-      logger.warning('This field is required');
-      continue;
-    }
-
-    if (validator && value) {
-      const validationResult = validator(value);
-      if (validationResult !== true) {
-        logger.warning(typeof validationResult === 'string' ? validationResult : 'Invalid input');
-        continue;
-      }
-    }
-
-    return value;
-  }
-}
-
-/**
- * Execute input step - collect plain text input
- */
-async function executeInputStep(step: InputStep, options: OnboardingOptions): Promise<string | null> {
-  const validator = step.validationPattern
-    ? createValidator(step.validationPattern, step.validationMessage)
-    : undefined;
-
-  // Use previous value as default if available (for refresh), otherwise use step's default
-  const previousValue = options.previousValues?.[step.configKey];
-  const defaultValue = previousValue ?? step.defaultValue;
-
-  if (previousValue && options.isRefresh) {
-    logger.dim(`  (current value: ${previousValue})`);
-  }
-
-  const value = await promptInput(`Enter ${step.title}:`, {
-    default: defaultValue,
-    validate: (input) => {
-      if (!input && step.required !== false) {
-        return 'This field is required';
-      }
-      if (validator && input) {
-        return validator(input);
-      }
-      return true;
-    },
-  });
-
-  return value;
-}
-
-/**
- * Create a validator function from regex pattern
- * Returns undefined if the pattern is invalid
- */
-function createValidator(
-  pattern: string,
-  message?: string
-): ((value: string) => boolean | string) | undefined {
-  try {
-    const regex = new RegExp(pattern);
-    return (value: string) => {
-      if (regex.test(value)) {
-        return true;
-      }
-      return message || `Value must match pattern: ${pattern}`;
-    };
-  } catch (error) {
-    logger.warning(`Invalid validation pattern '${pattern}', skipping validation`);
-    return undefined;
-  }
-}