issy 0.3.0 → 0.5.1

package/bin/issy

@@ -4,12 +4,19 @@ import {
 	existsSync,
 	mkdirSync,
 	readdirSync,
+	readFileSync,
 	writeFileSync,
-	readFileSync
+	renameSync,
+	cpSync
 } from 'node:fs'
 import { join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import updateNotifier from 'update-notifier'
+import {
+	detectPackageManager,
+	isGlobalInstall,
+	getUpdateCommand
+} from '../dist/update-checker.js'
 
 const args = process.argv.slice(2)
 
@@ -17,7 +24,21 @@ const args = process.argv.slice(2)
 const here = resolve(fileURLToPath(import.meta.url), '..')
 const pkgPath = resolve(here, '..', 'package.json')
 const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
-updateNotifier({ pkg, updateCheckInterval: 1000 * 60 * 60 }).notify() // 1 hour
+
+const notifier = updateNotifier({ pkg, updateCheckInterval: 1000 * 60 })
+
+if (notifier.update) {
+	const scriptPath = resolve(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',
@@ -26,6 +47,8 @@ const cliCommands = new Set([
 	'create',
 	'update',
 	'close',
+	'reopen',
+	'next',
 	'help',
 	'--help',
 	'-h'
@@ -38,10 +61,26 @@ if (args[0] === '--version' || args[0] === '-v') {
 }
 
 /**
- * Find .issues directory by walking up from the given path.
- * Returns the path if found, or null if not found.
+ * Find .issy directory by walking up from the given path.
  */
-function findIssuesDirUpward(fromPath) {
+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')
@@ -57,7 +96,6 @@ function findIssuesDirUpward(fromPath) {
 
 /**
  * Find the git repository root by walking up from the given path.
- * Returns the directory containing .git, or null if not in a git repo.
  */
 function findGitRoot(fromPath) {
 	let current = resolve(fromPath)
@@ -74,47 +112,154 @@ function findGitRoot(fromPath) {
 }
 
 /**
- * Resolve the issues directory using priority:
- * 1. ISSUES_DIR env var (explicit override)
- * 2. Walk up from ISSUES_ROOT or cwd to find existing .issues
- * 3. If in a git repo, use .issues at the repo root
- * 4. Fall back to creating .issues in ISSUES_ROOT or cwd
+ * 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 resolveIssuesDir() {
-	// 1. Explicit override
-	if (process.env.ISSUES_DIR) {
-		return resolve(process.env.ISSUES_DIR)
+function resolveIssyDir() {
+	if (process.env.ISSY_DIR) {
+		return resolve(process.env.ISSY_DIR)
 	}
 
-	// 2. Try to find existing .issues by walking up
-	const startDir = process.env.ISSUES_ROOT || process.cwd()
-	const found = findIssuesDirUpward(startDir)
+	const startDir = process.env.ISSY_ROOT || process.cwd()
+	const found = findIssyDirUpward(startDir)
 	if (found) {
 		return found
 	}
 
-	// 3. If in a git repo, use .issues at the repo root
 	const gitRoot = findGitRoot(startDir)
 	if (gitRoot) {
-		return join(gitRoot, '.issues')
+		return join(gitRoot, '.issy')
 	}
 
-	// 4. Fall back to creating in start directory
-	return join(resolve(startDir), '.issues')
+	return join(resolve(startDir), '.issy')
 }
 
-const issuesDir = resolveIssuesDir()
+const issyDir = resolveIssyDir()
+const issuesDir = join(issyDir, 'issues')
+
 // Set env vars for downstream consumers
-process.env.ISSUES_DIR = issuesDir
-// Set ISSUES_ROOT to the parent of .issues for consistency
-process.env.ISSUES_ROOT = dirname(issuesDir)
+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])
+	})
+
+	// 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 // Wait for main() to complete before exiting
+	await cli.ready
 	process.exit(0)
 }
 
@@ -126,18 +271,23 @@ if (portIdx >= 0 && args[portIdx + 1]) {
 const shouldInitOnly = args.includes('init')
 const shouldSeed = args.includes('--seed')
 
-// Only create .issues directory on explicit 'init' command
 if (shouldInitOnly) {
 	if (!existsSync(issuesDir)) {
 		mkdirSync(issuesDir, { recursive: true })
 	}
 
-	// Only seed with welcome issue if --seed flag is passed
 	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` +
@@ -145,6 +295,7 @@ if (shouldInitOnly) {
 				`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` +
@@ -154,7 +305,7 @@ if (shouldInitOnly) {
 		}
 	}
 
-	console.log(`Initialized ${issuesDir}`)
+	console.log(`Initialized ${issyDir}`)
 	process.exit(0)
 }
 

package/dist/cli.js

@@ -7,23 +7,209 @@ import { parseArgs } from "util";
 import { existsSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
+
+// ../../node_modules/.bun/fractional-indexing@3.2.0/node_modules/fractional-indexing/src/index.js
+var BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function midpoint(a, b, digits) {
+  const zero = digits[0];
+  if (b != null && a >= b) {
+    throw new Error(a + " >= " + b);
+  }
+  if (a.slice(-1) === zero || b && b.slice(-1) === zero) {
+    throw new Error("trailing zero");
+  }
+  if (b) {
+    let n = 0;
+    while ((a[n] || zero) === b[n]) {
+      n++;
+    }
+    if (n > 0) {
+      return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
+    }
+  }
+  const digitA = a ? digits.indexOf(a[0]) : 0;
+  const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
+  if (digitB - digitA > 1) {
+    const midDigit = Math.round(0.5 * (digitA + digitB));
+    return digits[midDigit];
+  } else {
+    if (b && b.length > 1) {
+      return b.slice(0, 1);
+    } else {
+      return digits[digitA] + midpoint(a.slice(1), null, digits);
+    }
+  }
+}
+function validateInteger(int) {
+  if (int.length !== getIntegerLength(int[0])) {
+    throw new Error("invalid integer part of order key: " + int);
+  }
+}
+function getIntegerLength(head) {
+  if (head >= "a" && head <= "z") {
+    return head.charCodeAt(0) - 97 + 2;
+  } else if (head >= "A" && head <= "Z") {
+    return 90 - head.charCodeAt(0) + 2;
+  } else {
+    throw new Error("invalid order key head: " + head);
+  }
+}
+function getIntegerPart(key) {
+  const integerPartLength = getIntegerLength(key[0]);
+  if (integerPartLength > key.length) {
+    throw new Error("invalid order key: " + key);
+  }
+  return key.slice(0, integerPartLength);
+}
+function validateOrderKey(key, digits) {
+  if (key === "A" + digits[0].repeat(26)) {
+    throw new Error("invalid order key: " + key);
+  }
+  const i = getIntegerPart(key);
+  const f = key.slice(i.length);
+  if (f.slice(-1) === digits[0]) {
+    throw new Error("invalid order key: " + key);
+  }
+}
+function incrementInteger(x, digits) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let carry = true;
+  for (let i = digs.length - 1;carry && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) + 1;
+    if (d === digits.length) {
+      digs[i] = digits[0];
+    } else {
+      digs[i] = digits[d];
+      carry = false;
+    }
+  }
+  if (carry) {
+    if (head === "Z") {
+      return "a" + digits[0];
+    }
+    if (head === "z") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) + 1);
+    if (h > "a") {
+      digs.push(digits[0]);
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function decrementInteger(x, digits) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let borrow = true;
+  for (let i = digs.length - 1;borrow && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) - 1;
+    if (d === -1) {
+      digs[i] = digits.slice(-1);
+    } else {
+      digs[i] = digits[d];
+      borrow = false;
+    }
+  }
+  if (borrow) {
+    if (head === "a") {
+      return "Z" + digits.slice(-1);
+    }
+    if (head === "A") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) - 1);
+    if (h < "Z") {
+      digs.push(digits.slice(-1));
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function generateKeyBetween(a, b, digits = BASE_62_DIGITS) {
+  if (a != null) {
+    validateOrderKey(a, digits);
+  }
+  if (b != null) {
+    validateOrderKey(b, digits);
+  }
+  if (a != null && b != null && a >= b) {
+    throw new Error(a + " >= " + b);
+  }
+  if (a == null) {
+    if (b == null) {
+      return "a" + digits[0];
+    }
+    const ib2 = getIntegerPart(b);
+    const fb2 = b.slice(ib2.length);
+    if (ib2 === "A" + digits[0].repeat(26)) {
+      return ib2 + midpoint("", fb2, digits);
+    }
+    if (ib2 < b) {
+      return ib2;
+    }
+    const res = decrementInteger(ib2, digits);
+    if (res == null) {
+      throw new Error("cannot decrement any more");
+    }
+    return res;
+  }
+  if (b == null) {
+    const ia2 = getIntegerPart(a);
+    const fa2 = a.slice(ia2.length);
+    const i2 = incrementInteger(ia2, digits);
+    return i2 == null ? ia2 + midpoint(fa2, null, digits) : i2;
+  }
+  const ia = getIntegerPart(a);
+  const fa = a.slice(ia.length);
+  const ib = getIntegerPart(b);
+  const fb = b.slice(ib.length);
+  if (ia === ib) {
+    return ia + midpoint(fa, fb, digits);
+  }
+  const i = incrementInteger(ia, digits);
+  if (i == null) {
+    throw new Error("cannot increment any more");
+  }
+  if (i < b) {
+    return i;
+  }
+  return ia + midpoint(fa, null, digits);
+}
+
+// ../core/src/lib/issues.ts
+var issyDir = null;
 var issuesDir = null;
-function setIssuesDir(dir) {
-  issuesDir = dir;
+function setIssyDir(dir) {
+  issyDir = dir;
+  issuesDir = join(dir, "issues");
+}
+function getIssyDir() {
+  if (!issyDir) {
+    throw new Error("Issy directory not initialized. Call resolveIssyDir() first.");
+  }
+  return issyDir;
 }
 function getIssuesDir() {
   if (!issuesDir) {
-    throw new Error("Issues directory not initialized. Call setIssuesDir() or resolveIssuesDir() first.");
+    throw new Error("Issues directory not initialized. Call resolveIssyDir() first.");
   }
   return issuesDir;
 }
 async function ensureIssuesDir() {
   await mkdir(getIssuesDir(), { recursive: true });
 }
-function findIssuesDirUpward(fromPath) {
+function findIssyDirUpward(fromPath) {
   let current = resolve(fromPath);
   for (let i = 0;i < 20; i++) {
-    const candidate = join(current, ".issues");
+    const candidate = join(current, ".issy");
     if (existsSync(candidate)) {
       return candidate;
     }
@@ -48,26 +234,26 @@ function findGitRoot(fromPath) {
   }
   return null;
 }
-function resolveIssuesDir() {
-  if (process.env.ISSUES_DIR) {
-    const dir = resolve(process.env.ISSUES_DIR);
-    setIssuesDir(dir);
+function resolveIssyDir() {
+  if (process.env.ISSY_DIR) {
+    const dir = resolve(process.env.ISSY_DIR);
+    setIssyDir(dir);
     return dir;
   }
-  const startDir = process.env.ISSUES_ROOT || process.cwd();
-  const found = findIssuesDirUpward(startDir);
+  const startDir = process.env.ISSY_ROOT || process.cwd();
+  const found = findIssyDirUpward(startDir);
   if (found) {
-    setIssuesDir(found);
+    setIssyDir(found);
     return found;
   }
   const gitRoot = findGitRoot(startDir);
   if (gitRoot) {
-    const gitIssuesDir = join(gitRoot, ".issues");
-    setIssuesDir(gitIssuesDir);
-    return gitIssuesDir;
+    const gitIssyDir = join(gitRoot, ".issy");
+    setIssyDir(gitIssyDir);
+    return gitIssyDir;
   }
-  const fallback = join(resolve(startDir), ".issues");
-  setIssuesDir(fallback);
+  const fallback = join(resolve(startDir), ".issy");
+  setIssyDir(fallback);
   return fallback;
 }
 function parseFrontmatter(content) {
@@ -101,6 +287,9 @@ function generateFrontmatter(data) {
     lines.push(`labels: ${data.labels}`);
   }
   lines.push(`status: ${data.status}`);
+  if (data.order) {
+    lines.push(`order: ${data.order}`);
+  }
   lines.push(`created: ${data.created}`);
   if (data.updated) {
     lines.push(`updated: ${data.updated}`);
@@ -165,16 +354,60 @@ async function getAllIssues() {
       content: body
     });
   }
-  const priorityOrder = { high: 0, medium: 1, low: 2 };
   return issues.sort((a, b) => {
-    const priorityA = priorityOrder[a.frontmatter.priority] ?? 999;
-    const priorityB = priorityOrder[b.frontmatter.priority] ?? 999;
-    if (priorityA !== priorityB) {
-      return priorityA - priorityB;
-    }
-    return b.id.localeCompare(a.id);
+    const orderA = a.frontmatter.order;
+    const orderB = b.frontmatter.order;
+    if (orderA && orderB)
+      return orderA < orderB ? -1 : orderA > orderB ? 1 : 0;
+    if (orderA && !orderB)
+      return -1;
+    if (!orderA && orderB)
+      return 1;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
   });
 }
+async function getOpenIssuesByOrder() {
+  const allIssues = await getAllIssues();
+  return allIssues.filter((i) => i.frontmatter.status === "open");
+}
+function computeOrderKey(openIssues, options, excludeId) {
+  const issues = excludeId ? openIssues.filter((i) => i.id !== excludeId.padStart(4, "0")) : openIssues;
+  if (options.first) {
+    if (issues.length === 0)
+      return generateKeyBetween(null, null);
+    const firstOrder = issues[0].frontmatter.order || null;
+    return generateKeyBetween(null, firstOrder);
+  }
+  if (options.last) {
+    if (issues.length === 0)
+      return generateKeyBetween(null, null);
+    const lastOrder2 = issues[issues.length - 1].frontmatter.order || null;
+    return generateKeyBetween(lastOrder2, null);
+  }
+  if (options.after) {
+    const targetId = options.after.padStart(4, "0");
+    const idx = issues.findIndex((i) => i.id === targetId);
+    if (idx === -1)
+      throw new Error(`Issue #${options.after} not found among open issues. The --after target must be an open issue.`);
+    const afterOrder = issues[idx].frontmatter.order || null;
+    const nextOrder = idx + 1 < issues.length ? issues[idx + 1].frontmatter.order || null : null;
+    return generateKeyBetween(afterOrder, nextOrder);
+  }
+  if (options.before) {
+    const targetId = options.before.padStart(4, "0");
+    const idx = issues.findIndex((i) => i.id === targetId);
+    if (idx === -1)
+      throw new Error(`Issue #${options.before} not found among open issues. The --before target must be an open issue.`);
+    const beforeOrder = issues[idx].frontmatter.order || null;
+    const prevOrder = idx > 0 ? issues[idx - 1].frontmatter.order || null : null;
+    return generateKeyBetween(prevOrder, beforeOrder);
+  }
+  if (issues.length === 0) {
+    return generateKeyBetween(null, null);
+  }
+  const lastOrder = issues[issues.length - 1].frontmatter.order || null;
+  return generateKeyBetween(lastOrder, null);
+}
 async function createIssue(input) {
   await ensureIssuesDir();
   if (!input.title) {
@@ -203,6 +436,7 @@ async function createIssue(input) {
     type,
     labels: input.labels || undefined,
     status: "open",
+    order: input.order || undefined,
     created: formatDate()
   };
   const content = `${generateFrontmatter(frontmatter)}
@@ -241,6 +475,7 @@ async function updateIssue(id, input) {
       labels: input.labels || undefined
     },
     ...input.status && { status: input.status },
+    ...input.order && { order: input.order },
     updated: formatDate()
   };
   const content = `${generateFrontmatter(updatedFrontmatter)}
@@ -254,6 +489,21 @@ ${issue.content}`;
 async function closeIssue(id) {
   return updateIssue(id, { status: "closed" });
 }
+async function reopenIssue(id, order) {
+  return updateIssue(id, { status: "open", order });
+}
+async function getOnCloseContent() {
+  try {
+    const onClosePath = join(getIssyDir(), "on_close.md");
+    return await readFile(onClosePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function getNextIssue() {
+  const openIssues = await getOpenIssuesByOrder();
+  return openIssues.length > 0 ? openIssues[0] : null;
+}
 // ../core/src/lib/query-parser.ts
 var SUPPORTED_QUALIFIERS = new Set([
   "is",
@@ -263,6 +513,59 @@ var SUPPORTED_QUALIFIERS = new Set([
   "label",
   "sort"
 ]);
+function parseQuery(query) {
+  const qualifiers = {};
+  const searchTextParts = [];
+  if (!query || !query.trim()) {
+    return { qualifiers, searchText: "" };
+  }
+  const tokens = tokenizeQuery(query);
+  for (const token of tokens) {
+    const colonIndex = token.indexOf(":");
+    if (colonIndex > 0 && colonIndex < token.length - 1) {
+      const key = token.substring(0, colonIndex);
+      const value = token.substring(colonIndex + 1);
+      if (SUPPORTED_QUALIFIERS.has(key)) {
+        qualifiers[key] = value;
+      } else {
+        searchTextParts.push(token);
+      }
+    } else {
+      searchTextParts.push(token);
+    }
+  }
+  return {
+    qualifiers,
+    searchText: searchTextParts.join(" ").trim()
+  };
+}
+function tokenizeQuery(query) {
+  const tokens = [];
+  let currentToken = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0;i < query.length; i++) {
+    const char = query[i];
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (char === " " && !inQuotes) {
+      if (currentToken) {
+        tokens.push(currentToken);
+        currentToken = "";
+      }
+    } else {
+      currentToken += char;
+    }
+  }
+  if (currentToken) {
+    tokens.push(currentToken);
+  }
+  return tokens;
+}
 // ../../node_modules/.bun/fuse.js@7.1.0/node_modules/fuse.js/dist/fuse.mjs
 function isArray(value) {
   return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
@@ -1099,7 +1402,7 @@ var searchers = [
 var searchersLen = searchers.length;
 var SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
 var OR_TOKEN = "|";
-function parseQuery(pattern, options = {}) {
+function parseQuery2(pattern, options = {}) {
   return pattern.split(OR_TOKEN).map((item) => {
     let query = item.trim().split(SPACE_RE).filter((item2) => item2 && !!item2.trim());
     let results = [];
@@ -1160,7 +1463,7 @@ class ExtendedSearch {
     pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
     pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
     this.pattern = pattern;
-    this.query = parseQuery(this.pattern, this.options);
+    this.query = parseQuery2(this.pattern, this.options);
   }
   static condition(_, options) {
     return options.useExtendedSearch;
@@ -1572,38 +1875,147 @@ var FUSE_OPTIONS = {
 function createSearchIndex(issues) {
   return new Fuse(issues, FUSE_OPTIONS);
 }
-function filterIssues(issues, filters) {
-  return issues.filter((issue) => {
-    if (filters.status && issue.frontmatter.status !== filters.status) {
-      return false;
+function sortIssues(issues, sortBy) {
+  const sortOption = sortBy.toLowerCase();
+  if (sortOption === "roadmap") {
+    issues.sort((a, b) => {
+      const orderA = a.frontmatter.order;
+      const orderB = b.frontmatter.order;
+      if (orderA && orderB)
+        return orderA < orderB ? -1 : orderA > orderB ? 1 : 0;
+      if (orderA && !orderB)
+        return -1;
+      if (!orderA && orderB)
+        return 1;
+      return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+  } else if (sortOption === "priority") {
+    const priorityOrder = {
+      high: 0,
+      medium: 1,
+      low: 2
+    };
+    issues.sort((a, b) => {
+      const priorityA = priorityOrder[a.frontmatter.priority] ?? 999;
+      const priorityB = priorityOrder[b.frontmatter.priority] ?? 999;
+      if (priorityA !== priorityB)
+        return priorityA - priorityB;
+      return b.id.localeCompare(a.id);
+    });
+  } else if (sortOption === "scope") {
+    const scopeOrder = {
+      small: 0,
+      medium: 1,
+      large: 2
+    };
+    issues.sort((a, b) => {
+      const scopeA = a.frontmatter.scope ? scopeOrder[a.frontmatter.scope] ?? 99 : 99;
+      const scopeB = b.frontmatter.scope ? scopeOrder[b.frontmatter.scope] ?? 99 : 99;
+      if (scopeA !== scopeB)
+        return scopeA - scopeB;
+      return b.id.localeCompare(a.id);
+    });
+  } else if (sortOption === "created") {
+    issues.sort((a, b) => {
+      const dateA = a.frontmatter.created || "";
+      const dateB = b.frontmatter.created || "";
+      if (dateA !== dateB)
+        return dateB.localeCompare(dateA);
+      return b.id.localeCompare(a.id);
+    });
+  } else if (sortOption === "created-asc") {
+    issues.sort((a, b) => {
+      const dateA = a.frontmatter.created || "";
+      const dateB = b.frontmatter.created || "";
+      if (dateA !== dateB)
+        return dateA.localeCompare(dateB);
+      return a.id.localeCompare(b.id);
+    });
+  } else if (sortOption === "updated") {
+    issues.sort((a, b) => {
+      const dateA = a.frontmatter.updated || a.frontmatter.created || "";
+      const dateB = b.frontmatter.updated || b.frontmatter.created || "";
+      if (dateA !== dateB)
+        return dateB.localeCompare(dateA);
+      return b.id.localeCompare(a.id);
+    });
+  } else if (sortOption === "id") {
+    issues.sort((a, b) => b.id.localeCompare(a.id));
+  } else {
+    issues.sort((a, b) => {
+      const orderA = a.frontmatter.order;
+      const orderB = b.frontmatter.order;
+      if (orderA && orderB)
+        return orderA < orderB ? -1 : orderA > orderB ? 1 : 0;
+      if (orderA && !orderB)
+        return -1;
+      if (!orderA && orderB)
+        return 1;
+      return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+  }
+}
+function filterByQuery(issues, query) {
+  const parsed = parseQuery(query);
+  let result = issues.filter((issue) => {
+    if (parsed.qualifiers.is) {
+      const statusValue = parsed.qualifiers.is.toLowerCase();
+      if (statusValue === "open" || statusValue === "closed") {
+        if (issue.frontmatter.status !== statusValue) {
+          return false;
+        }
+      }
     }
-    if (filters.priority && issue.frontmatter.priority !== filters.priority) {
-      return false;
+    if (parsed.qualifiers.priority) {
+      const priorityValue = parsed.qualifiers.priority.toLowerCase();
+      if (priorityValue === "high" || priorityValue === "medium" || priorityValue === "low") {
+        if (issue.frontmatter.priority !== priorityValue) {
+          return false;
+        }
+      }
+    }
+    if (parsed.qualifiers.scope) {
+      const scopeValue = parsed.qualifiers.scope.toLowerCase();
+      if (scopeValue === "small" || scopeValue === "medium" || scopeValue === "large") {
+        if (issue.frontmatter.scope !== scopeValue) {
+          return false;
+        }
+      }
     }
-    if (filters.scope && issue.frontmatter.scope !== filters.scope) {
-      return false;
+    if (parsed.qualifiers.type) {
+      const typeValue = parsed.qualifiers.type.toLowerCase();
+      if (typeValue === "bug" || typeValue === "improvement") {
+        if (issue.frontmatter.type !== typeValue) {
+          return false;
+        }
+      }
     }
-    if (filters.type && issue.frontmatter.type !== filters.type) {
-      return false;
+    if (parsed.qualifiers.label) {
+      const labelQuery = parsed.qualifiers.label.toLowerCase();
+      const issueLabels = (issue.frontmatter.labels || "").toLowerCase();
+      if (!issueLabels.includes(labelQuery)) {
+        return false;
+      }
     }
     return true;
   });
-}
-function filterAndSearchIssues(issues, filters) {
-  let result = filterIssues(issues, filters);
-  if (filters.search?.trim()) {
-    const query = filters.search.trim();
+  if (!parsed.searchText.trim()) {
+    const sortBy = parsed.qualifiers.sort?.toLowerCase() || "roadmap";
+    sortIssues(result, sortBy);
+  }
+  if (parsed.searchText.trim()) {
+    const searchQuery = parsed.searchText.trim();
     const idMatches = [];
     const nonIdMatches = [];
-    const normalizedQuery = query.replace(/^0+/, "");
+    const normalizedQuery = searchQuery.replace(/^0+/, "");
     for (const issue of result) {
       const normalizedId = issue.id.replace(/^0+/, "");
-      if (normalizedId.startsWith(normalizedQuery) || issue.id.startsWith(query)) {
+      if (normalizedId.startsWith(normalizedQuery) || issue.id.startsWith(searchQuery)) {
         idMatches.push(issue);
       }
     }
-    const fuse = createSearchIndex(issues);
-    const searchResults = fuse.search(query);
+    const fuse = createSearchIndex(result);
+    const searchResults = fuse.search(searchQuery);
     const matchedIds = new Set(searchResults.map((r) => r.item.id));
     const idMatchSet = new Set(idMatches.map((i) => i.id));
     for (const issue of result) {
@@ -1621,7 +2033,7 @@ function filterAndSearchIssues(issues, filters) {
   return result;
 }
 // src/cli.ts
-resolveIssuesDir();
+resolveIssyDir();
 function prioritySymbol(priority) {
   switch (priority) {
     case "high":
@@ -1637,15 +2049,46 @@ function prioritySymbol(priority) {
 function typeSymbol(type) {
   return type === "bug" ? "\uD83D\uDC1B" : "\u2728";
 }
+function formatIssueRow(issue) {
+  const status = issue.frontmatter.status === "open" ? "OPEN  " : "CLOSED";
+  return `  ${issue.id}  ${prioritySymbol(issue.frontmatter.priority)}   ${typeSymbol(issue.frontmatter.type)}    ${status}  ${issue.frontmatter.title.slice(0, 45)}`;
+}
+async function resolvePosition(opts) {
+  const openIssues = await getOpenIssuesByOrder();
+  const relevantIssues = opts.excludeId ? openIssues.filter((i) => i.id !== opts.excludeId?.padStart(4, "0")) : openIssues;
+  const positionFlags = [opts.before, opts.after, opts.first, opts.last].filter(Boolean).length;
+  if (positionFlags > 1) {
+    throw new Error("Only one of --before, --after, --first, or --last can be specified.");
+  }
+  const hasPosition = opts.before || opts.after || opts.first || opts.last;
+  if (relevantIssues.length > 0 && opts.requireIfOpenIssues && !hasPosition) {
+    const ids = relevantIssues.map((i) => `#${i.id}`).join(", ");
+    throw new Error(`A position flag (--before, --after, --first, or --last) is required when there are open issues. Open issues: ${ids}`);
+  }
+  return computeOrderKey(openIssues, {
+    before: opts.before,
+    after: opts.after,
+    first: opts.first,
+    last: opts.last
+  }, opts.excludeId);
+}
 async function listIssues(options) {
   const allIssues = await getAllIssues();
-  const issues = filterAndSearchIssues(allIssues, {
-    status: options.all ? undefined : "open",
-    priority: options.priority,
-    scope: options.scope,
-    type: options.type,
-    search: options.search
-  });
+  const queryParts = [];
+  if (!options.all)
+    queryParts.push("is:open");
+  if (options.priority)
+    queryParts.push(`priority:${options.priority}`);
+  if (options.scope)
+    queryParts.push(`scope:${options.scope}`);
+  if (options.type)
+    queryParts.push(`type:${options.type}`);
+  if (options.sort)
+    queryParts.push(`sort:${options.sort}`);
+  if (options.search)
+    queryParts.push(options.search);
+  const query = queryParts.join(" ") || "is:open";
+  const issues = filterByQuery(allIssues, query);
   if (issues.length === 0) {
     console.log("No issues found.");
     return;
@@ -1654,8 +2097,7 @@ async function listIssues(options) {
   ID    Pri  Type  Status   Title`);
   console.log(`  ${"-".repeat(70)}`);
   for (const issue of issues) {
-    const status = issue.frontmatter.status === "open" ? "OPEN  " : "CLOSED";
-    console.log(`  ${issue.id}  ${prioritySymbol(issue.frontmatter.priority)}   ${typeSymbol(issue.frontmatter.type)}    ${status}  ${issue.frontmatter.title.slice(0, 45)}`);
+    console.log(formatIssueRow(issue));
   }
   console.log(`
   Total: ${issues.length} issue(s)
@@ -1681,6 +2123,9 @@ ${"=".repeat(70)}`);
   if (issue.frontmatter.labels) {
     console.log(`  Labels:      ${issue.frontmatter.labels}`);
   }
+  if (issue.frontmatter.order) {
+    console.log(`  Order:       ${issue.frontmatter.order}`);
+  }
   console.log(`  Created:     ${issue.frontmatter.created}`);
   if (issue.frontmatter.updated) {
     console.log(`  Updated:     ${issue.frontmatter.updated}`);
@@ -1691,10 +2136,8 @@ ${"=".repeat(70)}`);
 }
 async function searchIssuesCommand(query, options) {
   const allIssues = await getAllIssues();
-  const issues = filterAndSearchIssues(allIssues, {
-    status: options.all ? undefined : "open",
-    search: query
-  });
+  const searchQuery = options.all ? query : `is:open ${query}`;
+  const issues = filterByQuery(allIssues, searchQuery);
   if (issues.length === 0) {
     console.log(`No issues found matching "${query}".`);
     return;
@@ -1705,8 +2148,7 @@ async function searchIssuesCommand(query, options) {
   ID    Pri  Type  Status   Title`);
   console.log(`  ${"-".repeat(70)}`);
   for (const issue of issues) {
-    const status = issue.frontmatter.status === "open" ? "OPEN  " : "CLOSED";
-    console.log(`  ${issue.id}  ${prioritySymbol(issue.frontmatter.priority)}   ${typeSymbol(issue.frontmatter.type)}    ${status}  ${issue.frontmatter.title.slice(0, 45)}`);
+    console.log(formatIssueRow(issue));
   }
   console.log(`
   Found: ${issues.length} issue(s)
@@ -1746,13 +2188,21 @@ Create New Issue`);
     process.exit(1);
   }
   try {
+    const order = await resolvePosition({
+      before: options.before,
+      after: options.after,
+      first: options.first,
+      last: options.last,
+      requireIfOpenIssues: true
+    });
     const input = {
       title: options.title,
       description: options.description,
       priority: options.priority,
       scope: options.scope,
       type: options.type,
-      labels: options.labels
+      labels: options.labels,
+      order
     };
     const issue = await createIssue(input);
     console.log(`
@@ -1764,6 +2214,17 @@ Created issue: ${issue.filename}`);
 }
 async function updateIssueCommand(id, options) {
   try {
+    let order;
+    if (options.before || options.after || options.first || options.last) {
+      order = await resolvePosition({
+        before: options.before,
+        after: options.after,
+        first: options.first,
+        last: options.last,
+        requireIfOpenIssues: false,
+        excludeId: id
+      });
+    }
     const issue = await updateIssue(id, {
       title: options.title,
       description: options.description,
@@ -1771,7 +2232,7 @@ async function updateIssueCommand(id, options) {
       scope: options.scope,
       type: options.type,
       labels: options.labels,
-      status: options.status
+      order
     });
     console.log(`Updated issue: ${issue.filename}`);
   } catch (e) {
@@ -1783,11 +2244,49 @@ async function closeIssueCommand(id) {
   try {
     await closeIssue(id);
     console.log("Issue closed.");
+    const onCloseContent = await getOnCloseContent();
+    if (onCloseContent) {
+      console.log(`
+${onCloseContent.trim()}
+`);
+    }
   } catch (e) {
     console.error(e instanceof Error ? e.message : "Failed to close issue");
     process.exit(1);
   }
 }
+async function reopenIssueCommand(id, options) {
+  try {
+    const order = await resolvePosition({
+      before: options.before,
+      after: options.after,
+      first: options.first,
+      last: options.last,
+      requireIfOpenIssues: true,
+      excludeId: id
+    });
+    await reopenIssue(id, order);
+    console.log("Issue reopened.");
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : "Failed to reopen issue");
+    process.exit(1);
+  }
+}
+async function nextIssueCommand() {
+  const issue = await getNextIssue();
+  if (!issue) {
+    console.log("No open issues.");
+    return;
+  }
+  console.log(`
+  Next issue:`);
+  console.log(`  ${"-".repeat(60)}`);
+  console.log(`  #${issue.id}  ${prioritySymbol(issue.frontmatter.priority)} ${typeSymbol(issue.frontmatter.type)}  ${issue.frontmatter.title}`);
+  if (issue.frontmatter.description !== issue.frontmatter.title) {
+    console.log(`  ${issue.frontmatter.description}`);
+  }
+  console.log();
+}
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
@@ -1802,25 +2301,32 @@ Options:
   --version, -v           Show version number
 
 Commands:
-  list                    List all open issues
+  list                    List all open issues (roadmap order)
     --all, -a             Include closed issues
     --priority, -p <p>    Filter by priority (high, medium, low)
     --scope <s>           Filter by scope (small, medium, large)
     --type, -t <t>        Filter by type (bug, improvement)
     --search, -s <q>      Fuzzy search issues
+    --sort <s>            Sort: roadmap (default), priority, created, updated, id
 
   search <query>          Fuzzy search issues
     --all, -a             Include closed issues
 
   read <id>               Read a specific issue
 
-  create                  Create a new issue (interactive)
+  next                    Show the next issue to work on
+
+  create                  Create a new issue
     --title, -t <t>       Issue title
     --description, -d <d> Short description
     --priority, -p <p>    Priority (high, medium, low)
     --scope <s>           Scope (small, medium, large)
     --type <t>            Type (bug, improvement)
     --labels, -l <l>      Comma-separated labels
+    --before <id>         Insert before this issue in roadmap
+    --after <id>          Insert after this issue in roadmap
+    --first               Insert at the beginning of the roadmap
+    --last                Insert at the end of the roadmap
 
   update <id>             Update an issue
     --title, -t <t>       New title
@@ -1829,20 +2335,30 @@ Commands:
     --scope <s>           New scope
     --type <t>            New type
     --labels, -l <l>      New labels
-    --status, -s <s>      New status (open, closed)
+    --before <id>         Move before this issue in roadmap
+    --after <id>          Move after this issue in roadmap
+    --first               Move to the beginning of the roadmap
+    --last                Move to the end of the roadmap
 
   close <id>              Close an issue
 
+  reopen <id>             Reopen a closed issue
+    --before <id>         Insert before this issue in roadmap
+    --after <id>          Insert after this issue in roadmap
+    --first               Insert at the beginning of the roadmap
+    --last                Insert at the end of the roadmap
+
 Examples:
   issy list
   issy list --priority high --type bug
-  issy list --scope large
-  issy search "dashboard"
-  issy search "k8s" --all
+  issy next
   issy read 0001
-  issy create --title "Fix login bug" --type bug --priority high --scope small
-  issy update 0001 --priority low --scope medium
+  issy create --title "Fix login bug" --type bug --priority high --after 0002
+  issy create --title "Add dark mode" --last
+  issy create --title "Urgent fix" --first
+  issy update 0001 --priority low --after 0003
   issy close 0001
+  issy reopen 0001 --last
 `);
     return;
   }
@@ -1855,7 +2371,8 @@ Examples:
           priority: { type: "string", short: "p" },
           scope: { type: "string" },
           type: { type: "string", short: "t" },
-          search: { type: "string", short: "s" }
+          search: { type: "string", short: "s" },
+          sort: { type: "string" }
         },
         allowPositionals: true
       });
@@ -1887,6 +2404,10 @@ Examples:
       await readIssue(id);
       break;
     }
+    case "next": {
+      await nextIssueCommand();
+      break;
+    }
     case "create": {
       const { values } = parseArgs({
         args: args.slice(1),
@@ -1896,7 +2417,11 @@ Examples:
           priority: { type: "string", short: "p" },
           scope: { type: "string" },
           type: { type: "string" },
-          labels: { type: "string", short: "l" }
+          labels: { type: "string", short: "l" },
+          before: { type: "string" },
+          after: { type: "string" },
+          first: { type: "boolean" },
+          last: { type: "boolean" }
         },
         allowPositionals: true
       });
@@ -1918,7 +2443,10 @@ Examples:
           scope: { type: "string" },
           type: { type: "string" },
           labels: { type: "string", short: "l" },
-          status: { type: "string", short: "s" }
+          before: { type: "string" },
+          after: { type: "string" },
+          first: { type: "boolean" },
+          last: { type: "boolean" }
         },
         allowPositionals: true
       });
@@ -1934,6 +2462,25 @@ Examples:
       await closeIssueCommand(id);
       break;
     }
+    case "reopen": {
+      const id = args[1];
+      if (!id) {
+        console.error("Usage: issy reopen <id>");
+        process.exit(1);
+      }
+      const { values } = parseArgs({
+        args: args.slice(2),
+        options: {
+          before: { type: "string" },
+          after: { type: "string" },
+          first: { type: "boolean" },
+          last: { type: "boolean" }
+        },
+        allowPositionals: true
+      });
+      await reopenIssueCommand(id, values);
+      break;
+    }
     default:
       console.error(`Unknown command: ${command}`);
       console.log('Run "issy help" for usage.');

package/dist/update-checker.js

@@ -0,0 +1,99 @@
+// src/update-checker.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+function detectPackageManagerFromPath(scriptPath) {
+  if (scriptPath.includes("/.bun/"))
+    return "bun";
+  if (scriptPath.includes("/pnpm/") || scriptPath.includes("/.pnpm"))
+    return "pnpm";
+  if (scriptPath.includes("/.yarn/") || scriptPath.includes("/yarn/global"))
+    return "yarn";
+  if (scriptPath.includes("/.nvm/"))
+    return "npm";
+  if (scriptPath.includes("/usr/local/lib/node_modules") || scriptPath.includes("/usr/lib/node_modules") || scriptPath.includes("/.npm-global/")) {
+    return "npm";
+  }
+  return null;
+}
+function detectPackageManager(scriptPath, env = process.env, cwd = process.cwd()) {
+  if (scriptPath) {
+    const fromPath = detectPackageManagerFromPath(scriptPath);
+    if (fromPath)
+      return fromPath;
+  }
+  const userAgent = env.npm_config_user_agent || "";
+  if (userAgent.includes("bun/"))
+    return "bun";
+  if (userAgent.includes("pnpm/"))
+    return "pnpm";
+  if (userAgent.includes("yarn/"))
+    return "yarn";
+  if (userAgent.includes("npm/"))
+    return "npm";
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock")))
+    return "bun";
+  if (existsSync(join(cwd, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock")))
+    return "yarn";
+  if (existsSync(join(cwd, "package-lock.json")))
+    return "npm";
+  return "npm";
+}
+function isGlobalInstall(scriptPath, env = process.env) {
+  if (env.npm_config_global === "true")
+    return true;
+  const globalPaths = [
+    "/usr/local/lib/node_modules",
+    "/usr/lib/node_modules",
+    join(env.HOME || "", ".npm-global"),
+    join(env.HOME || "", ".nvm"),
+    join(env.HOME || "", ".bun/install/global"),
+    join(env.APPDATA || "", "npm"),
+    join(env.LOCALAPPDATA || "", "pnpm/global")
+  ].filter(Boolean);
+  for (const globalPath of globalPaths) {
+    if (scriptPath.startsWith(globalPath))
+      return true;
+  }
+  const parts = scriptPath.split("/node_modules/");
+  if (parts.length > 1) {
+    const projectRoot = parts[0];
+    if (existsSync(join(projectRoot, "package.json"))) {
+      return false;
+    }
+  }
+  if (env.npm_execpath?.includes("npx") || env._?.includes("npx") || env._?.includes("bunx") || env._?.includes("pnpm dlx")) {
+    return true;
+  }
+  return true;
+}
+function getUpdateCommand(packageManager, isGlobal) {
+  const pkgName = "issy";
+  const commands = {
+    npm: {
+      global: `npm install -g ${pkgName}`,
+      local: `npm update ${pkgName}`
+    },
+    yarn: {
+      global: `yarn global add ${pkgName}`,
+      local: `yarn upgrade ${pkgName}`
+    },
+    pnpm: {
+      global: `pnpm add -g ${pkgName}`,
+      local: `pnpm update ${pkgName}`
+    },
+    bun: {
+      global: `bun add -g ${pkgName}`,
+      local: `bun update ${pkgName}`
+    }
+  };
+  const pm = commands[packageManager] || commands.npm;
+  return isGlobal ? pm.global : pm.local;
+}
+export {
+  isGlobalInstall,
+  getUpdateCommand,
+  detectPackageManagerFromPath,
+  detectPackageManager
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "issy",
-  "version": "0.3.0",
+  "version": "0.5.1",
   "description": "AI-native issue tracking. Markdown files in .issues/, managed by your coding assistant.",
   "type": "module",
   "license": "MIT",
@@ -28,14 +28,15 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "bun build src/cli.ts --outdir dist --target node --format esm --external @miketromba/issy-app",
+    "build": "bun build src/cli.ts src/update-checker.ts --outdir dist --target node --format esm --external @miketromba/issy-app",
     "prepublishOnly": "bun run build",
     "cli": "bun src/cli.ts",
+    "test": "bun test",
     "lint": "biome check src bin"
   },
   "dependencies": {
-    "@miketromba/issy-app": "^0.3.0",
-    "@miketromba/issy-core": "^0.3.0",
+    "@miketromba/issy-app": "workspace:^",
+    "@miketromba/issy-core": "workspace:^",
     "update-notifier": "^7.3.1"
   }
 }