issy 0.5.2 → 0.5.4

package/bin/issy

@@ -1,313 +1,36 @@
 #!/usr/bin/env node
-import { dirname } from 'node:path'
-import {
-	existsSync,
-	mkdirSync,
-	readdirSync,
-	readFileSync,
-	writeFileSync,
-	renameSync,
-	cpSync
-} from 'node:fs'
-import { join, resolve } from 'node:path'
+import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import updateNotifier from 'update-notifier'
 import {
 	detectPackageManager,
 	isGlobalInstall,
-	getUpdateCommand
+	getUpdateCommand,
 } from '../dist/update-checker.js'
 
-const args = process.argv.slice(2)
-
-// Check for updates (non-blocking, cached, shows on next run)
-const here = resolve(fileURLToPath(import.meta.url), '..')
-const pkgPath = resolve(here, '..', 'package.json')
-const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const pkg = JSON.parse(
+	readFileSync(resolve(__dirname, '..', 'package.json'), 'utf-8'),
+)
 
 const notifier = updateNotifier({ pkg, updateCheckInterval: 1000 * 60 })
-
 if (notifier.update) {
-	const scriptPath = resolve(fileURLToPath(import.meta.url))
+	const scriptPath = fileURLToPath(import.meta.url)
 	const pm = detectPackageManager(scriptPath)
 	const isGlobal = isGlobalInstall(scriptPath)
 	const updateCmd = getUpdateCommand(pm, isGlobal)
-	
 	notifier.notify({
 		message: `Update available: ${notifier.update.current} → ${notifier.update.latest}\nRun: ${updateCmd}`,
 		defer: true,
-		boxenOptions: { padding: 1, margin: 1, borderStyle: 'round', borderColor: 'yellow' }
-	})
-}
-
-const cliCommands = new Set([
-	'list',
-	'search',
-	'read',
-	'create',
-	'update',
-	'close',
-	'reopen',
-	'next',
-	'help',
-	'--help',
-	'-h'
-])
-
-// Handle --version / -v flag
-if (args[0] === '--version' || args[0] === '-v') {
-	console.log(`issy v${pkg.version}`)
-	process.exit(0)
-}
-
-/**
- * Find .issy directory by walking up from the given path.
- */
-function findIssyDirUpward(fromPath) {
-	let current = resolve(fromPath)
-	for (let i = 0; i < 20; i++) {
-		const candidate = join(current, '.issy')
-		if (existsSync(candidate)) {
-			return candidate
-		}
-		const parent = dirname(current)
-		if (parent === current) break
-		current = parent
-	}
-	return null
-}
-
-/**
- * Find legacy .issues directory by walking up (for migration detection).
- */
-function findLegacyIssuesDir(fromPath) {
-	let current = resolve(fromPath)
-	for (let i = 0; i < 20; i++) {
-		const candidate = join(current, '.issues')
-		if (existsSync(candidate)) {
-			return candidate
-		}
-		const parent = dirname(current)
-		if (parent === current) break
-		current = parent
-	}
-	return null
-}
-
-/**
- * Find the git repository root by walking up from the given path.
- */
-function findGitRoot(fromPath) {
-	let current = resolve(fromPath)
-	for (let i = 0; i < 20; i++) {
-		const gitDir = join(current, '.git')
-		if (existsSync(gitDir)) {
-			return current
-		}
-		const parent = dirname(current)
-		if (parent === current) break
-		current = parent
-	}
-	return null
-}
-
-/**
- * Resolve the .issy directory using priority:
- * 1. ISSY_DIR env var (explicit override)
- * 2. Walk up from cwd to find existing .issy
- * 3. If in a git repo, use .issy at the repo root
- * 4. Fall back to cwd/.issy
- */
-function resolveIssyDir() {
-	if (process.env.ISSY_DIR) {
-		return resolve(process.env.ISSY_DIR)
-	}
-
-	const startDir = process.env.ISSY_ROOT || process.cwd()
-	const found = findIssyDirUpward(startDir)
-	if (found) {
-		return found
-	}
-
-	const gitRoot = findGitRoot(startDir)
-	if (gitRoot) {
-		return join(gitRoot, '.issy')
-	}
-
-	return join(resolve(startDir), '.issy')
-}
-
-const issyDir = resolveIssyDir()
-const issuesDir = join(issyDir, 'issues')
-
-// Set env vars for downstream consumers
-process.env.ISSY_DIR = issyDir
-process.env.ISSY_ROOT = dirname(issyDir)
-
-// Detect legacy .issues/ directory and warn (unless running migrate)
-const legacyDir = findLegacyIssuesDir(process.env.ISSY_ROOT || process.cwd())
-if (legacyDir && args[0] !== 'migrate' && args[0] !== 'init') {
-	// Only warn if .issy doesn't exist yet (haven't migrated)
-	if (!existsSync(issyDir)) {
-		console.warn(`⚠️  Legacy .issues/ directory detected at ${legacyDir}`)
-		console.warn(`   Run "issy migrate" to upgrade to the new .issy/ structure.\n`)
-	}
-}
-
-// --- Handle commands ---
-
-if (args[0] === 'migrate') {
-	const startDir = process.env.ISSY_ROOT || process.cwd()
-	const legacy = findLegacyIssuesDir(startDir)
-
-	if (!legacy) {
-		console.log('No legacy .issues/ directory found. Nothing to migrate.')
-		process.exit(0)
-	}
-
-	if (existsSync(issyDir) && existsSync(issuesDir)) {
-		console.log('.issy/issues/ already exists. Migration may have already been completed.')
-		process.exit(1)
-	}
-
-	console.log(`Migrating ${legacy} → ${issuesDir}`)
-
-	// Create .issy/issues/
-	mkdirSync(issuesDir, { recursive: true })
-
-	// Copy issue files
-	const files = readdirSync(legacy).filter(f => f.endsWith('.md') && /^\d{4}-/.test(f))
-
-	// We'll use fractional-indexing to assign initial order keys to open issues.
-	// Since we can't import ESM from the bundled core here easily,
-	// we assign order keys inline using the same algorithm.
-	// Import dynamically from the built core.
-	let generateNKeysBetween
-	try {
-		const fi = await import('fractional-indexing')
-		generateNKeysBetween = fi.generateNKeysBetween
-	} catch {
-		console.error('Failed to load fractional-indexing. Please ensure dependencies are installed.')
-		process.exit(1)
-	}
-
-	// Parse frontmatter from each file and sort by ID
-	const issueData = files.map(f => {
-		const content = readFileSync(join(legacy, f), 'utf-8')
-		const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
-		const frontmatter = {}
-		if (match) {
-			for (const line of match[1].split('\n')) {
-				const colonIdx = line.indexOf(':')
-				if (colonIdx > 0) {
-					frontmatter[line.slice(0, colonIdx).trim()] = line.slice(colonIdx + 1).trim()
-				}
-			}
-		}
-		return { filename: f, content, frontmatter }
-	}).sort((a, b) => a.filename.localeCompare(b.filename))
-
-	// Assign order keys to open issues
-	const openIssues = issueData.filter(i => i.frontmatter.status === 'open')
-	const orderKeys = generateNKeysBetween(null, null, openIssues.length)
-
-	const orderMap = new Map()
-	openIssues.forEach((issue, idx) => {
-		orderMap.set(issue.filename, orderKeys[idx])
+		boxenOptions: {
+			padding: 1,
+			margin: 1,
+			borderStyle: 'round',
+			borderColor: 'yellow',
+		},
 	})
-
-	// Write migrated files with order keys
-	for (const issue of issueData) {
-		let content = issue.content
-		const orderKey = orderMap.get(issue.filename)
-
-		if (orderKey) {
-			// Insert order field before the status line
-			content = content.replace(
-				/^(---\n[\s\S]*?)(status: \w+)/m,
-				`$1$2\norder: ${orderKey}`
-			)
-		}
-
-		writeFileSync(join(issuesDir, issue.filename), content)
-	}
-
-	// Copy any non-issue files (e.g., README)
-	const otherFiles = readdirSync(legacy).filter(f => !files.includes(f))
-	for (const f of otherFiles) {
-		const src = join(legacy, f)
-		const dest = join(issuesDir, f)
-		try {
-			cpSync(src, dest, { recursive: true })
-		} catch { /* skip if can't copy */ }
-	}
-
-	// Remove legacy directory
-	const { rmSync } = await import('node:fs')
-	rmSync(legacy, { recursive: true })
-
-	console.log(`✅ Migrated ${files.length} issue(s) to ${issuesDir}`)
-	if (openIssues.length > 0) {
-		console.log(`   Assigned roadmap order to ${openIssues.length} open issue(s).`)
-	}
-	console.log(`   Removed ${legacy}`)
-	process.exit(0)
-}
-
-if (cliCommands.has(args[0] || '')) {
-	const here = resolve(fileURLToPath(import.meta.url), '..')
-	const entry = resolve(here, '..', 'dist', 'cli.js')
-	process.argv = [process.argv[0], process.argv[1], ...args]
-	const cli = await import(entry)
-	await cli.ready
-	process.exit(0)
-}
-
-const portIdx = args.findIndex(arg => arg === '--port' || arg === '-p')
-if (portIdx >= 0 && args[portIdx + 1]) {
-	process.env.ISSUES_PORT = args[portIdx + 1]
-}
-
-const shouldInitOnly = args.includes('init')
-const shouldSeed = args.includes('--seed')
-
-if (shouldInitOnly) {
-	if (!existsSync(issuesDir)) {
-		mkdirSync(issuesDir, { recursive: true })
-	}
-
-	if (shouldSeed) {
-		const hasIssues =
-			existsSync(issuesDir) &&
-			readdirSync(issuesDir).some(f => f.endsWith('.md'))
-		if (!hasIssues) {
-			// First issue gets the initial order key
-			let firstOrderKey = 'a0'
-			try {
-				const fi = await import('fractional-indexing')
-				firstOrderKey = fi.generateKeyBetween(null, null)
-			} catch { /* use fallback */ }
-
-			const welcome =
-				`---\n` +
-				`title: Welcome to issy\n` +
-				`description: Your first issue in this repo\n` +
-				`priority: medium\n` +
-				`type: improvement\n` +
-				`status: open\n` +
-				`order: ${firstOrderKey}\n` +
-				`created: ${new Date().toISOString().slice(0, 19)}\n` +
-				`---\n\n` +
-				`## Details\n\n` +
-				`- This issue was created automatically on first run.\n` +
-				`- Edit it, close it, or delete it to get started.\n`
-			writeFileSync(join(issuesDir, '0001-welcome-to-issy.md'), welcome)
-		}
-	}
-
-	console.log(`Initialized ${issyDir}`)
-	process.exit(0)
 }
 
-// Start the server
-await import('@miketromba/issy-app')
+process.env.ISSY_PKG_VERSION = pkg.version
+await import('../dist/main.js')

package/dist/cli.js

@@ -1,8 +1,8 @@
-#!/usr/bin/env bun
-// @bun
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli.ts
-import { parseArgs } from "util";
+import { parseArgs } from "node:util";
 // ../core/src/lib/issues.ts
 import { existsSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
@@ -183,6 +183,40 @@ function generateKeyBetween(a, b, digits = BASE_62_DIGITS) {
   }
   return ia + midpoint(fa, null, digits);
 }
+function generateNKeysBetween(a, b, n, digits = BASE_62_DIGITS) {
+  if (n === 0) {
+    return [];
+  }
+  if (n === 1) {
+    return [generateKeyBetween(a, b, digits)];
+  }
+  if (b == null) {
+    let c2 = generateKeyBetween(a, b, digits);
+    const result = [c2];
+    for (let i = 0;i < n - 1; i++) {
+      c2 = generateKeyBetween(c2, b, digits);
+      result.push(c2);
+    }
+    return result;
+  }
+  if (a == null) {
+    let c2 = generateKeyBetween(a, b, digits);
+    const result = [c2];
+    for (let i = 0;i < n - 1; i++) {
+      c2 = generateKeyBetween(a, c2, digits);
+      result.push(c2);
+    }
+    result.reverse();
+    return result;
+  }
+  const mid = Math.floor(n / 2);
+  const c = generateKeyBetween(a, b, digits);
+  return [
+    ...generateNKeysBetween(a, c, mid, digits),
+    c,
+    ...generateNKeysBetween(c, b, n - mid - 1, digits)
+  ];
+}
 
 // ../core/src/lib/issues.ts
 var issyDir = null;
@@ -220,6 +254,20 @@ function findIssyDirUpward(fromPath) {
   }
   return null;
 }
+function findLegacyIssuesDirUpward(fromPath) {
+  let current = resolve(fromPath);
+  for (let i = 0;i < 20; i++) {
+    const candidate = join(current, ".issues");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return null;
+}
 function findGitRoot(fromPath) {
   let current = resolve(fromPath);
   for (let i = 0;i < 20; i++) {
@@ -408,6 +456,9 @@ function computeOrderKey(openIssues, options, excludeId) {
   const lastOrder = issues[issues.length - 1].frontmatter.order || null;
   return generateKeyBetween(lastOrder, null);
 }
+function generateBatchOrderKeys(count) {
+  return generateNKeysBetween(null, null, count);
+}
 async function createIssue(input) {
   await ensureIssuesDir();
   if (!input.title) {
@@ -2043,11 +2094,11 @@ function prioritySymbol(priority) {
     case "low":
       return "\uD83D\uDFE2";
     default:
-      return "\u26AA";
+      return "⚪";
   }
 }
 function typeSymbol(type) {
-  return type === "bug" ? "\uD83D\uDC1B" : "\u2728";
+  return type === "bug" ? "\uD83D\uDC1B" : "✨";
 }
 function formatIssueRow(issue) {
   const status = issue.frontmatter.status === "open" ? "OPEN  " : "CLOSED";