@haoyiyin/workflow 0.2.2 → 0.2.3

package/src/utils/compress.ts

@@ -0,0 +1,347 @@
+/**
+ * Text Compression Utility - Compresses verbose output to terse prose
+ *
+ * Pure text transformation. No subagent dispatch needed.
+ * Use case: Take verbose AI output and compress it to essential facts.
+ *
+ * Pattern: Input text → Compression rules → Terse output
+ */
+
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+export interface CompressOptions {
+  style: 'terse' | 'bullets' | 'oneline'
+  maxLength?: number
+}
+
+export interface CompressResult {
+  compressed: string
+  originalLength: number
+  compressedLength: number
+  compressionRatio: number
+  sectionsRemoved: number
+}
+
+// ---------------------------------------------------------------------------
+// Compression rules (pure functions, immutable)
+// ---------------------------------------------------------------------------
+
+/** Words and phrases that can be removed without losing meaning */
+const FILLER_PATTERNS: ReadonlyArray<{ pattern: RegExp; replacement: string }> = [
+  { pattern: /\b(?:basically|essentially|fundamentally)\b/gi, replacement: '' },
+  { pattern: /\b(?:actually|literally|virtually)\b/gi, replacement: '' },
+  { pattern: /\b(?:obviously|clearly|evidently)\b/gi, replacement: '' },
+  { pattern: /\b(?:interestingly|notably|importantly)\b/gi, replacement: '' },
+  { pattern: /\b(?:I think|I believe|in my opinion|it seems that|it appears that)\b/gi, replacement: '' },
+  { pattern: /\b(?:as mentioned|as noted|as discussed|as previously stated)\b/gi, replacement: '' },
+  { pattern: /\b(?:it is worth noting that|it should be noted that|note that)\b/gi, replacement: '' },
+  { pattern: /\b(?:in order to)\b/gi, replacement: 'to' },
+  { pattern: /\b(?:due to the fact that)\b/gi, replacement: 'because' },
+  { pattern: /\b(?:at this point in time)\b/gi, replacement: 'now' },
+  { pattern: /\b(?:in the event that)\b/gi, replacement: 'if' },
+  { pattern: /\b(?:a number of)\b/gi, replacement: 'several' },
+  { pattern: /\b(?:the majority of)\b/gi, replacement: 'most' },
+  { pattern: /\b(?:a large number of)\b/gi, replacement: 'many' },
+  { pattern: /\b(?:in the near future)\b/gi, replacement: 'soon' },
+  { pattern: /\b(?:has the ability to)\b/gi, replacement: 'can' },
+  { pattern: /\b(?:is able to)\b/gi, replacement: 'can' },
+  { pattern: /\b(?:is capable of)\b/gi, replacement: 'can' },
+  { pattern: /\b(?:make a decision)\b/gi, replacement: 'decide' },
+  { pattern: /\b(?:take into account)\b/gi, replacement: 'consider' },
+  { pattern: /\b(?:with regard to|in regard to|with respect to)\b/gi, replacement: 'about' },
+  { pattern: /\b(?:in the process of)\b/gi, replacement: '' },
+  { pattern: /\b(?:please note that)\b/gi, replacement: '' },
+  { pattern: /\b(?:I would like to|I want to|I will now|let me)\b/gi, replacement: '' },
+  { pattern: /\b(?:here is|here are|below is|below are)\b/gi, replacement: '' },
+  { pattern: /\b(?:the following(?: is| are)?)\b/gi, replacement: '' },
+]
+
+/** Section headers that can be collapsed */
+const SECTION_PATTERNS: ReadonlyArray<RegExp> = [
+  /^#{1,4}\s+Introduction\b/gim,
+  /^#{1,4}\s+Overview\b/gim,
+  /^#{1,4}\s+Background\b/gim,
+  /^#{1,4}\s+Context\b/gim,
+  /^#{1,4}\s+Disclaimer\b/gim,
+  /^#{1,4}\s+Note\b/gim,
+  /^#{1,4}\s+Notes?\b/gim,
+  /^#{1,4}\s+Additional Information\b/gim,
+]
+
+/** Lines that are purely transitional and can be removed */
+const TRANSITION_PATTERNS: ReadonlyArray<RegExp> = [
+  /^(?:Now|Next|Then|Finally|Firstly|Secondly|Thirdly|Lastly),\s*.+$/gim,
+  /^(?:Moving on|Let'?s move on|Let'?s continue).+$/gim,
+  /^(?:To summarize|In summary|To conclude|In conclusion|Wrapping up).*$/gim,
+  /^(?:Without further ado|As you can see).*$/gim,
+]
+
+// ---------------------------------------------------------------------------
+// Core compression functions (pure, immutable)
+// ---------------------------------------------------------------------------
+
+/**
+ * Apply all filler-word replacements to the text.
+ * Each rule is applied sequentially on the accumulated result (immutable pattern).
+ */
+function removeFillerWords(text: string): string {
+  let result = text
+  for (const { pattern, replacement } of FILLER_PATTERNS) {
+    result = result.replace(pattern, replacement)
+  }
+  return result
+}
+
+/**
+ * Remove known section headers that add no information.
+ */
+function removeBoilerplateSections(text: string): string {
+  let result = text
+  for (const pattern of SECTION_PATTERNS) {
+    // Remove the header line and the following paragraph until next header or blank line
+    result = result.replace(
+      new RegExp(`${pattern.source}\\n*(?:[^#\\n]\\n*)*`, 'gim'),
+      '',
+    )
+  }
+  return result
+}
+
+/**
+ * Remove transitional sentences that don't carry content.
+ */
+function removeTransitions(text: string): string {
+  let result = text
+  for (const pattern of TRANSITION_PATTERNS) {
+    result = result.replace(pattern, '')
+  }
+  return result
+}
+
+/**
+ * Collapse multiple blank lines into a single blank line.
+ */
+function collapseWhitespace(text: string): string {
+  return text
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/[ \t]+/g, ' ')
+    .replace(/^[ \t]+/gm, '')
+    .replace(/[ \t]+$/gm, '')
+    .trim()
+}
+
+/**
+ * Collapse repeated sentences (simple cosine of word overlap).
+ */
+function deduplicateSentences(text: string): string {
+  const sentences = text.match(/[^.!?\n]+[.!?]?/g) ?? []
+  if (sentences.length <= 1) return text
+
+  const seen = new Set<string>()
+  const kept: string[] = []
+
+  for (const sentence of sentences) {
+    // Normalize for comparison: lowercase, strip punctuation, sort words
+    const normalized = sentence
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, '')
+      .trim()
+      .split(/\s+/)
+      .filter((w) => w.length > 2)
+      .sort()
+      .join(' ')
+
+    if (normalized.length < 10) {
+      kept.push(sentence)
+      continue
+    }
+
+    if (seen.has(normalized)) continue
+
+    // Check for near-duplicates (Jaccard similarity)
+    let isDuplicate = false
+    const words = new Set(normalized.split(' '))
+    for (const existing of seen) {
+      const existingWords = new Set(existing.split(' '))
+      const intersection = [...words].filter((w) => existingWords.has(w)).length
+      const union = new Set([...words, ...existingWords]).size
+      if (union > 0 && intersection / union > 0.7) {
+        isDuplicate = true
+        break
+      }
+    }
+
+    if (!isDuplicate) {
+      seen.add(normalized)
+      kept.push(sentence)
+    }
+  }
+
+  return kept.join(' ')
+}
+
+/**
+ * Extract the key sentences: first sentence, sentences with numbers/data,
+ * sentences with key action verbs.
+ */
+function extractKeySentences(text: string): string {
+  const sentences = text.match(/[^.!?\n]+[.!?]?/g) ?? []
+  if (sentences.length <= 3) return text
+
+  const scored = sentences.map((s, i) => {
+    let score = 0
+    // First sentence is important
+    if (i === 0) score += 3
+    // Sentences with data/numbers
+    if (/\d/.test(s)) score += 2
+    // Sentences with code indicators
+    if (/[`'']|```|function|class|import|export|const|let|var/.test(s)) score += 2
+    // Sentences with action verbs
+    if (/\b(must|should|need|require|fix|change|update|create|delete|remove|add)\b/i.test(s)) score += 2
+    // Short sentences (likely statements of fact)
+    if (s.length < 80) score += 1
+    // Last sentence (conclusion)
+    if (i === sentences.length - 1) score += 2
+    return { sentence: s, score }
+  })
+
+  // Keep top-scoring sentences (at least 2, at most 60% of original)
+  const keepCount = Math.max(2, Math.ceil(sentences.length * 0.6))
+  const sorted = [...scored].sort((a, b) => b.score - a.score)
+  const kept = sorted.slice(0, keepCount)
+  // Restore original order
+  const keptSet = new Set(kept.map((k) => k.sentence))
+  return sentences.filter((s) => keptSet.has(s)).join(' ')
+}
+
+/**
+ * Convert prose to bullet points by splitting on sentence boundaries
+ * and prefixing each meaningful chunk with "-".
+ */
+function toBullets(text: string): string {
+  const sentences = text.match(/[^.!?\n]+[.!?]?/g) ?? []
+  if (sentences.length <= 1) return text
+
+  return sentences
+    .map((s) => s.trim())
+    .filter((s) => s.length > 5)
+    .map((s) => `- ${s}`)
+    .join('\n')
+}
+
+/**
+ * Convert text to a single line by replacing all newlines with spaces.
+ */
+function toOneLine(text: string): string {
+  return text.replace(/\n+/g, ' ').replace(/\s{2,}/g, ' ').trim()
+}
+
+/**
+ * Truncate text to maxLength characters, preserving word boundaries.
+ */
+function truncateToMaxLength(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text
+  const truncated = text.slice(0, maxLength)
+  const lastSpace = truncated.lastIndexOf(' ')
+  if (lastSpace > maxLength * 0.8) {
+    return truncated.slice(0, lastSpace) + '...'
+  }
+  return truncated + '...'
+}
+
+/**
+ * Count the number of sections (markdown headers) in the text.
+ */
+function countSections(text: string): number {
+  const matches = text.match(/^#{1,4}\s+.+$/gm)
+  return matches ? matches.length : 0
+}
+
+// ---------------------------------------------------------------------------
+// Main compression pipeline
+// ---------------------------------------------------------------------------
+
+/**
+ * Compress verbose text through a pipeline of transformations.
+ * All steps are pure functions that return new strings (immutable pattern).
+ */
+export function compressText(text: string, options: CompressOptions): CompressResult {
+  const originalLength = text.length
+  const sectionsBefore = countSections(text)
+
+  // Stage 1: Remove filler words and verbose phrases
+  let result = removeFillerWords(text)
+
+  // Stage 2: Remove boilerplate sections
+  result = removeBoilerplateSections(result)
+
+  // Stage 3: Remove transitional fluff
+  result = removeTransitions(result)
+
+  // Stage 4: Deduplicate near-identical sentences
+  result = deduplicateSentences(result)
+
+  // Stage 5: Extract key sentences when text is lengthy
+  if (result.length > 500) {
+    result = extractKeySentences(result)
+  }
+
+  // Stage 6: Apply style formatting
+  switch (options.style) {
+    case 'bullets':
+      result = toBullets(result)
+      break
+    case 'oneline':
+      result = toOneLine(result)
+      break
+    case 'terse':
+      // Terse is the default prose after all prior stages
+      break
+  }
+
+  // Stage 7: Collapse whitespace
+  result = collapseWhitespace(result)
+
+  // Stage 8: Truncate if needed
+  if (options.maxLength && result.length > options.maxLength) {
+    result = truncateToMaxLength(result, options.maxLength)
+  }
+
+  const sectionsAfter = countSections(result)
+  const compressedLength = result.length
+  const compressionRatio =
+    originalLength > 0
+      ? Math.round(((originalLength - compressedLength) / originalLength) * 100) / 100
+      : 0
+
+  return {
+    compressed: result,
+    originalLength,
+    compressedLength,
+    compressionRatio,
+    sectionsRemoved: Math.max(0, sectionsBefore - sectionsAfter),
+  }
+}
+
+/**
+ * Convenience function for terse compression
+ */
+export function compressTerse(text: string, maxLength?: number): string {
+  return compressText(text, { style: 'terse', maxLength }).compressed
+}
+
+/**
+ * Convenience function for bullet compression
+ */
+export function compressBullets(text: string, maxLength?: number): string {
+  return compressText(text, { style: 'bullets', maxLength }).compressed
+}
+
+/**
+ * Convenience function for one-line compression
+ */
+export function compressOneLine(text: string, maxLength?: number): string {
+  return compressText(text, { style: 'oneline', maxLength }).compressed
+}

package/src/utils/git.ts

@@ -0,0 +1,82 @@
+/**
+ * Git utility functions
+ */
+import { execSync } from 'child_process'
+
+export function getCurrentBranch(cwd: string): string {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd,
+      encoding: 'utf-8',
+    }).trim()
+  } catch {
+    throw new Error('Not a git repository')
+  }
+}
+
+export function getBaseBranch(cwd: string): string | null {
+  try {
+    // Try main first
+    execSync('git rev-parse --verify main', { cwd })
+    return 'main'
+  } catch {
+    try {
+      // Fallback to master
+      execSync('git rev-parse --verify master', { cwd })
+      return 'master'
+    } catch {
+      return null
+    }
+  }
+}
+
+export function isWorktree(cwd: string): boolean {
+  try {
+    const gitDir = execSync('git rev-parse --git-dir', {
+      cwd,
+      encoding: 'utf-8',
+    }).trim()
+    return gitDir.includes('.git/worktrees')
+  } catch {
+    return false
+  }
+}
+
+export function getWorktreePath(cwd: string): string | null {
+  if (!isWorktree(cwd)) return null
+
+  try {
+    return execSync('git rev-parse --show-toplevel', {
+      cwd,
+      encoding: 'utf-8',
+    }).trim()
+  } catch {
+    return null
+  }
+}
+
+export function hasUncommittedChanges(cwd: string): boolean {
+  try {
+    const status = execSync('git status --porcelain', {
+      cwd,
+      encoding: 'utf-8',
+    })
+    return status.trim().length > 0
+  } catch {
+    return false
+  }
+}
+
+export function commitChanges(cwd: string, message: string): void {
+  execSync('git add -A', { cwd })
+  execSync(`git commit -m "${message}"`, { cwd })
+}
+
+export function mergeBranch(cwd: string, branch: string, base: string): void {
+  execSync(`git checkout ${base}`, { cwd })
+  execSync(`git merge ${branch}`, { cwd })
+}
+
+export function deleteBranch(cwd: string, branch: string): void {
+  execSync(`git branch -D ${branch}`, { cwd })
+}

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Utilities index
+ */
+export * from './logger.js'
+export * from './paths.js'
+export * from './git.js'

package/src/utils/logger.ts

@@ -0,0 +1,23 @@
+/**
+ * Logger utility for yi-workflow
+ */
+import type { Logger } from '../types.js'
+
+export function createLogger(verbose = false): Logger {
+  return {
+    info: (message: string, ...args: unknown[]) => {
+      console.log(`[INFO] ${message}`, ...args)
+    },
+    warn: (message: string, ...args: unknown[]) => {
+      console.warn(`[WARN] ${message}`, ...args)
+    },
+    error: (message: string, ...args: unknown[]) => {
+      console.error(`[ERROR] ${message}`, ...args)
+    },
+    debug: (message: string, ...args: unknown[]) => {
+      if (verbose) {
+        console.log(`[DEBUG] ${message}`, ...args)
+      }
+    },
+  }
+}

package/src/utils/paths.ts

@@ -0,0 +1,55 @@
+/**
+ * Path management utilities
+ */
+import { join, dirname, resolve } from 'path'
+import { fileURLToPath } from 'url'
+import { homedir } from 'os'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+export function getPackageRoot(): string {
+  return resolve(__dirname, '../..')
+}
+
+export function getConfigPath(): string {
+  return join(homedir(), '.config', 'yi-workflow', 'config.json')
+}
+
+export function getCachePath(): string {
+  return join(homedir(), '.cache', 'yi-workflow')
+}
+
+export function getPiPath(cwd: string): string {
+  return join(cwd, '.pi')
+}
+
+export function getPlansPath(cwd: string): string {
+  return join(cwd, '.pi', 'plans')
+}
+
+export function getStatePath(cwd: string): string {
+  return join(cwd, '.pi', 'yi-workflow', 'state')
+}
+
+export function getActivePlansPath(cwd: string): string {
+  return join(getPlansPath(cwd), 'active')
+}
+
+export function getArchivePlansPath(cwd: string): string {
+  return join(getPlansPath(cwd), 'archive')
+}
+
+export function getActiveStatePath(cwd: string): string {
+  return join(getStatePath(cwd), 'active')
+}
+
+export function getArchiveStatePath(cwd: string): string {
+  return join(getStatePath(cwd), 'archive')
+}
+
+export function generatePlanFileName(topic: string): string {
+  const date = new Date().toISOString().split('T')[0]
+  const sanitized = topic.toLowerCase().replace(/[^a-z0-9]+/g, '-')
+  return `${date}-${sanitized}-implementation-plan.md`
+}