@miketromba/issy-core 0.1.0

package/README.md

@@ -0,0 +1,31 @@
+# @miketromba/issy-core
+
+Shared issue storage/search library used by the issy CLI and UI.
+
+## Install
+
+```bash
+npm install @miketromba/issy-core
+```
+
+## Usage
+
+```ts
+import { setIssuesDir, createIssue, getAllIssues } from "@miketromba/issy-core";
+
+setIssuesDir("/path/to/repo/.issues");
+await createIssue({
+  title: "Add dark mode",
+  description: "Theme toggle",
+  priority: "medium",
+  type: "improvement",
+});
+
+const issues = await getAllIssues();
+```
+
+## API
+
+- CRUD: `createIssue`, `updateIssue`, `getIssue`, `getAllIssues`, `closeIssue`
+- Search: `filterByQuery`, `filterAndSearchIssues`
+- Helpers: `parseQuery`, `getQuerySuggestions`

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@miketromba/issy-core",
+  "version": "0.1.0",
+  "description": "Issue storage, search, and parsing for issy",
+  "type": "module",
+  "license": "MIT",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/miketromba/issy.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/miketromba/issy/issues"
+  },
+  "homepage": "https://github.com/miketromba/issy#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "bun test"
+  },
+  "exports": {
+    ".": "./src/lib/index.ts"
+  },
+  "files": [
+    "src/lib"
+  ],
+  "dependencies": {
+    "date-fns": "^4.1.0",
+    "fuse.js": "^7.1.0"
+  }
+}

package/src/lib/autocomplete.ts

@@ -0,0 +1,234 @@
+/**
+ * Autocomplete suggestions for query input
+ *
+ * Provides context-aware suggestions based on the current query string
+ * and cursor position.
+ */
+
+/**
+ * A suggestion for autocomplete
+ */
+export interface Suggestion {
+	/** The text to insert when selected */
+	text: string
+	/** The text to display in the dropdown */
+	displayText: string
+	/** Optional helper text describing the suggestion */
+	description?: string
+}
+
+/**
+ * Supported qualifier keys
+ */
+const QUALIFIER_KEYS = ['is', 'priority', 'type', 'label', 'sort'] as const
+
+/**
+ * Valid values for each qualifier
+ */
+const QUALIFIER_VALUES: Record<string, readonly string[]> = {
+	is: ['open', 'closed'] as const,
+	priority: ['high', 'medium', 'low'] as const,
+	type: ['bug', 'improvement'] as const,
+	sort: ['priority', 'created', 'updated', 'id'] as const
+	// label values are dynamic and provided via existingLabels parameter
+}
+
+/**
+ * Get autocomplete suggestions for a query string at a given cursor position
+ *
+ * @param query - The current query string
+ * @param cursorPosition - The cursor position (defaults to end of string)
+ * @param existingLabels - Optional array of existing labels to suggest for label: qualifier
+ * @returns Array of suggestions, ordered by relevance
+ *
+ * @example
+ * getQuerySuggestions("is:", 3)
+ * // [{ text: "open", displayText: "open", description: "Open issues" }, ...]
+ *
+ * @example
+ * getQuerySuggestions("pri", 3)
+ * // [{ text: "priority:", displayText: "priority:", description: "Filter by priority" }, ...]
+ */
+export function getQuerySuggestions(
+	query: string,
+	cursorPosition?: number,
+	existingLabels?: string[]
+): Suggestion[] {
+	// Default cursor position to end of string
+	const cursor = cursorPosition ?? query.length
+
+	// Get the text up to the cursor
+	const textBeforeCursor = query.substring(0, cursor)
+
+	// Find the current token being typed
+	const { currentToken, tokenStart } = findCurrentToken(textBeforeCursor)
+
+	// If we're in the middle of a qualifier (key:value)
+	if (currentToken.includes(':')) {
+		const colonIndex = currentToken.indexOf(':')
+		const qualifierKey = currentToken.substring(0, colonIndex)
+		const partialValue = currentToken.substring(colonIndex + 1)
+
+		// Check if it's a supported qualifier
+		if (QUALIFIER_KEYS.includes(qualifierKey as any)) {
+			return getValueSuggestions(
+				qualifierKey,
+				partialValue,
+				existingLabels
+			)
+		}
+	}
+
+	// Check if we're typing a qualifier key (with or without colon)
+	const partialQualifier = currentToken
+	if (partialQualifier && !partialQualifier.includes(':')) {
+		const matchingKeys = QUALIFIER_KEYS.filter(key =>
+			key.startsWith(partialQualifier.toLowerCase())
+		)
+
+		if (matchingKeys.length > 0) {
+			return matchingKeys.map(key => ({
+				text: `${key}:`,
+				displayText: `${key}:`,
+				description: getQualifierDescription(key)
+			}))
+		}
+	}
+
+	// If we're at the start of a new token (space or start of string)
+	// and the previous token doesn't end with a colon, suggest qualifier keys
+	if (currentToken === '' || currentToken.trim() === '') {
+		const previousToken = getPreviousToken(textBeforeCursor)
+		if (!previousToken || !previousToken.endsWith(':')) {
+			return QUALIFIER_KEYS.map(key => ({
+				text: `${key}:`,
+				displayText: `${key}:`,
+				description: getQualifierDescription(key)
+			}))
+		}
+	}
+
+	return []
+}
+
+/**
+ * Get suggestions for a qualifier value
+ */
+function getValueSuggestions(
+	qualifierKey: string,
+	partialValue: string,
+	existingLabels?: string[]
+): Suggestion[] {
+	const suggestions: Suggestion[] = []
+
+	if (qualifierKey === 'label') {
+		// For labels, use existing labels if provided
+		if (existingLabels && existingLabels.length > 0) {
+			const matchingLabels = existingLabels
+				.filter(label =>
+					label.toLowerCase().includes(partialValue.toLowerCase())
+				)
+				.slice(0, 10) // Limit to 10 suggestions
+
+			return matchingLabels.map(label => ({
+				text: label,
+				displayText: label,
+				description: 'Label'
+			}))
+		}
+		return []
+	}
+
+	// For other qualifiers, use predefined values
+	const validValues = QUALIFIER_VALUES[qualifierKey]
+	if (!validValues) {
+		return []
+	}
+
+	const matchingValues = validValues.filter(value =>
+		value.toLowerCase().startsWith(partialValue.toLowerCase())
+	)
+
+	return matchingValues.map(value => ({
+		text: value,
+		displayText: value,
+		description: getValueDescription(qualifierKey, value)
+	}))
+}
+
+/**
+ * Find the current token being typed at the cursor position
+ */
+function findCurrentToken(text: string): {
+	currentToken: string
+	tokenStart: number
+} {
+	if (!text) {
+		return { currentToken: '', tokenStart: 0 }
+	}
+
+	// Find the start of the current token (last space or start of string)
+	let tokenStart = text.length
+	for (let i = text.length - 1; i >= 0; i--) {
+		if (text[i] === ' ') {
+			tokenStart = i + 1
+			break
+		}
+		if (i === 0) {
+			tokenStart = 0
+		}
+	}
+
+	const currentToken = text.substring(tokenStart)
+	return { currentToken, tokenStart }
+}
+
+/**
+ * Get the previous token before the cursor
+ */
+function getPreviousToken(text: string): string | null {
+	if (!text || text.trim() === '') {
+		return null
+	}
+
+	const tokens = text.trim().split(/\s+/)
+	if (tokens.length < 2) {
+		return null
+	}
+
+	// Get the second-to-last token
+	return tokens[tokens.length - 2]
+}
+
+/**
+ * Get a human-readable description for a qualifier key
+ */
+function getQualifierDescription(key: string): string {
+	const descriptions: Record<string, string> = {
+		is: 'Filter by status',
+		priority: 'Filter by priority',
+		type: 'Filter by type',
+		label: 'Filter by label',
+		sort: 'Sort results'
+	}
+	return descriptions[key] || ''
+}
+
+/**
+ * Get a human-readable description for a qualifier value
+ */
+function getValueDescription(key: string, value: string): string {
+	if (key === 'is') {
+		return value === 'open' ? 'Open issues' : 'Closed issues'
+	}
+	if (key === 'priority') {
+		return `Priority: ${value}`
+	}
+	if (key === 'type') {
+		return value === 'bug' ? 'Bug report' : 'Improvement'
+	}
+	if (key === 'sort') {
+		return `Sort by ${value}`
+	}
+	return ''
+}

package/src/lib/formatDate.ts

@@ -0,0 +1,54 @@
+import { formatDistanceToNow, format, parseISO, isValid } from 'date-fns'
+
+/**
+ * Format a date string for user-friendly display
+ * Shows relative time for recent dates, full date for older ones
+ */
+export function formatDisplayDate(dateStr: string | undefined): string {
+  if (!dateStr) return ''
+  
+  try {
+    // Handle both YYYY-MM-DD and ISO formats
+    const date = dateStr.includes('T') ? parseISO(dateStr) : parseISO(dateStr + 'T00:00:00')
+    
+    if (!isValid(date)) return dateStr
+    
+    const now = new Date()
+    const diffInDays = Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24))
+    
+    if (diffInDays < 7) {
+      // Within last week: "2 days ago", "3 hours ago"
+      // Remove "about" prefix for cleaner output
+      return formatDistanceToNow(date, { addSuffix: true }).replace(/^about /, '')
+    } else if (diffInDays < 365) {
+      // Within last year: "Jan 15"
+      return format(date, 'MMM d')
+    } else {
+      // Older: "Jan 15, 2024"
+      return format(date, 'MMM d, yyyy')
+    }
+  } catch {
+    return dateStr
+  }
+}
+
+/**
+ * Format a date string for tooltip (full date and time)
+ */
+export function formatFullDate(dateStr: string | undefined): string {
+  if (!dateStr) return ''
+  
+  try {
+    const date = dateStr.includes('T') ? parseISO(dateStr) : parseISO(dateStr + 'T00:00:00')
+    
+    if (!isValid(date)) return dateStr
+    
+    // If it has time info, show it
+    if (dateStr.includes('T')) {
+      return format(date, 'MMM d, yyyy \'at\' h:mm a')
+    }
+    return format(date, 'MMM d, yyyy')
+  } catch {
+    return dateStr
+  }
+}

package/src/lib/index.ts

@@ -0,0 +1,57 @@
+/**
+ * Issue Tracking Library
+ *
+ * Shared library for reading, writing, and searching issues.
+ * Used by both the API server and CLI.
+ */
+
+// Types
+export type {
+	Issue,
+	IssueFrontmatter,
+	IssueFilters,
+	CreateIssueInput,
+	UpdateIssueInput
+} from './types'
+
+// Core issue operations
+export {
+	setIssuesDir,
+	getIssuesDir,
+	ensureIssuesDir,
+	autoDetectIssuesDir,
+	parseFrontmatter,
+	generateFrontmatter,
+	getIssueIdFromFilename,
+	createSlug,
+	formatDate,
+	getIssueFiles,
+	getNextIssueNumber,
+	getIssue,
+	getAllIssues,
+	createIssue,
+	updateIssue,
+	closeIssue,
+	reopenIssue,
+	deleteIssue
+} from './issues'
+
+// Search functionality
+export {
+	createSearchIndex,
+	searchIssues,
+	filterIssues,
+	filterAndSearchIssues,
+	filterByQuery
+} from './search'
+
+// Query parser
+export type { ParsedQuery } from './query-parser'
+export { parseQuery } from './query-parser'
+
+// Autocomplete
+export type { Suggestion } from './autocomplete'
+export { getQuerySuggestions } from './autocomplete'
+
+// Date formatting helpers (UI)
+export { formatDisplayDate, formatFullDate } from './formatDate'

package/src/lib/issues.ts

@@ -0,0 +1,344 @@
+/**
+ * Core issue operations - read, write, create, update, close
+ * This is the shared library used by both the API and CLI
+ */
+
+import { readdir, readFile, writeFile, mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import type {
+	Issue,
+	IssueFrontmatter,
+	CreateIssueInput,
+	UpdateIssueInput
+} from './types'
+
+// Default issues directory - can be overridden
+let issuesDir: string | null = null
+
+/**
+ * Initialize the issues directory path
+ */
+export function setIssuesDir(dir: string) {
+	issuesDir = dir
+}
+
+/**
+ * Get the issues directory path
+ */
+export function getIssuesDir(): string {
+	if (!issuesDir) {
+		throw new Error(
+			'Issues directory not initialized. Call setIssuesDir() first.'
+		)
+	}
+	return issuesDir
+}
+
+/**
+ * Ensure issues directory exists
+ */
+export async function ensureIssuesDir(): Promise<void> {
+	await mkdir(getIssuesDir(), { recursive: true })
+}
+
+/**
+ * Auto-detect issues directory from common locations
+ */
+export function autoDetectIssuesDir(fromPath: string): string {
+	// Try to find .issues directory by walking up from the given path
+	const { resolve, dirname } = require('node:path')
+	const { existsSync } = require('node:fs')
+
+	let current = resolve(fromPath)
+	for (let i = 0; i < 10; i++) {
+		const candidate = join(current, '.issues')
+		if (existsSync(candidate)) {
+			return candidate
+		}
+		const parent = dirname(current)
+		if (parent === current) break
+		current = parent
+	}
+
+	throw new Error('Could not find .issues directory')
+}
+
+/**
+ * Parse YAML front matter from issue content
+ */
+export function parseFrontmatter(content: string): {
+	frontmatter: Partial<IssueFrontmatter>
+	body: string
+} {
+	const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+	if (!match) {
+		return { frontmatter: {}, body: content }
+	}
+
+	const [, frontmatterStr, body] = match
+	const frontmatter: Partial<IssueFrontmatter> = {}
+
+	for (const line of frontmatterStr.split('\n')) {
+		const colonIdx = line.indexOf(':')
+		if (colonIdx > 0) {
+			const key = line.slice(0, colonIdx).trim()
+			const value = line.slice(colonIdx + 1).trim()
+			;(frontmatter as Record<string, string>)[key] = value
+		}
+	}
+
+	return { frontmatter, body }
+}
+
+/**
+ * Generate YAML front matter string from issue data
+ */
+export function generateFrontmatter(data: IssueFrontmatter): string {
+	const lines = ['---']
+	lines.push(`title: ${data.title}`)
+	lines.push(`description: ${data.description}`)
+	lines.push(`priority: ${data.priority}`)
+	lines.push(`type: ${data.type}`)
+	if (data.labels) {
+		lines.push(`labels: ${data.labels}`)
+	}
+	lines.push(`status: ${data.status}`)
+	lines.push(`created: ${data.created}`)
+	if (data.updated) {
+		lines.push(`updated: ${data.updated}`)
+	}
+	lines.push('---')
+	return lines.join('\n')
+}
+
+/**
+ * Get issue ID from filename (e.g., "0001-fix-bug.md" -> "0001")
+ */
+export function getIssueIdFromFilename(filename: string): string {
+	const match = filename.match(/^(\d+)-/)
+	return match ? match[1] : filename.replace('.md', '')
+}
+
+/**
+ * Create URL-friendly slug from title
+ */
+export function createSlug(title: string): string {
+	return title
+		.toLowerCase()
+		.replace(/[^a-z0-9\s-]/g, '')
+		.replace(/\s+/g, '-')
+		.replace(/-+/g, '-')
+		.slice(0, 50)
+}
+
+/**
+ * Format date as ISO 8601 timestamp (YYYY-MM-DDTHH:mm:ss)
+ * This provides second-level precision for better sorting
+ */
+export function formatDate(date: Date = new Date()): string {
+	return date.toISOString().slice(0, 19)
+}
+
+/**
+ * Get all issue filenames from the issues directory
+ */
+export async function getIssueFiles(): Promise<string[]> {
+	try {
+		const files = await readdir(getIssuesDir())
+		return files.filter(f => f.endsWith('.md') && /^\d{4}-/.test(f))
+	} catch {
+		return []
+	}
+}
+
+/**
+ * Get the next available issue number
+ */
+export async function getNextIssueNumber(): Promise<string> {
+	const files = await getIssueFiles()
+	if (files.length === 0) return '0001'
+
+	const numbers = files
+		.map(f => parseInt(getIssueIdFromFilename(f), 10))
+		.filter(n => !isNaN(n))
+
+	const max = Math.max(...numbers, 0)
+	return String(max + 1).padStart(4, '0')
+}
+
+/**
+ * Load a single issue by ID
+ */
+export async function getIssue(id: string): Promise<Issue | null> {
+	const files = await getIssueFiles()
+	const paddedId = id.padStart(4, '0')
+
+	const file = files.find(
+		f => f.startsWith(paddedId) || getIssueIdFromFilename(f) === paddedId
+	)
+
+	if (!file) return null
+
+	const filepath = join(getIssuesDir(), file)
+	const content = await readFile(filepath, 'utf-8')
+	const { frontmatter, body } = parseFrontmatter(content)
+
+	return {
+		id: getIssueIdFromFilename(file),
+		filename: file,
+		frontmatter: frontmatter as IssueFrontmatter,
+		content: body
+	}
+}
+
+/**
+ * Load all issues
+ */
+export async function getAllIssues(): Promise<Issue[]> {
+	const files = await getIssueFiles()
+	const issues: Issue[] = []
+
+	for (const file of files) {
+		const filepath = join(getIssuesDir(), file)
+		const content = await readFile(filepath, 'utf-8')
+		const { frontmatter, body } = parseFrontmatter(content)
+
+		issues.push({
+			id: getIssueIdFromFilename(file),
+			filename: file,
+			frontmatter: frontmatter as IssueFrontmatter,
+			content: body
+		})
+	}
+
+	// Sort by priority (high → medium → low), then by ID (newest first) within each priority
+	const priorityOrder: Record<string, number> = { 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
+		}
+		// Within same priority, sort by ID descending (newest first)
+		return b.id.localeCompare(a.id)
+	})
+}
+
+/**
+ * Create a new issue
+ */
+export async function createIssue(input: CreateIssueInput): Promise<Issue> {
+	await ensureIssuesDir()
+	if (!input.title) {
+		throw new Error('Title is required')
+	}
+
+	const priority = input.priority || 'medium'
+	const type = input.type || 'improvement'
+
+	if (!['high', 'medium', 'low'].includes(priority)) {
+		throw new Error('Priority must be: high, medium, or low')
+	}
+
+	if (!['bug', 'improvement'].includes(type)) {
+		throw new Error('Type must be: bug or improvement')
+	}
+
+	const issueNumber = await getNextIssueNumber()
+	const slug = createSlug(input.title)
+	const filename = `${issueNumber}-${slug}.md`
+
+	const frontmatter: IssueFrontmatter = {
+		title: input.title,
+		description: input.description || input.title,
+		priority,
+		type,
+		labels: input.labels || undefined,
+		status: 'open',
+		created: formatDate()
+	}
+
+	const content = `${generateFrontmatter(frontmatter)}
+
+## Details
+
+<!-- Add detailed description here -->
+
+`
+
+	await writeFile(join(getIssuesDir(), filename), content)
+
+	return {
+		id: issueNumber,
+		filename,
+		frontmatter,
+		content: '\n## Details\n\n<!-- Add detailed description here -->\n\n'
+	}
+}
+
+/**
+ * Update an existing issue
+ */
+export async function updateIssue(
+	id: string,
+	input: UpdateIssueInput
+): Promise<Issue> {
+	const issue = await getIssue(id)
+
+	if (!issue) {
+		throw new Error(`Issue not found: ${id}`)
+	}
+
+	// Update fields
+	const updatedFrontmatter: IssueFrontmatter = {
+		...issue.frontmatter,
+		...(input.title && { title: input.title }),
+		...(input.description && { description: input.description }),
+		...(input.priority && { priority: input.priority }),
+		...(input.type && { type: input.type }),
+		...(input.labels !== undefined && {
+			labels: input.labels || undefined
+		}),
+		...(input.status && { status: input.status }),
+		updated: formatDate()
+	}
+
+	const content = `${generateFrontmatter(updatedFrontmatter)}
+${issue.content}`
+
+	await writeFile(join(getIssuesDir(), issue.filename), content)
+
+	return {
+		...issue,
+		frontmatter: updatedFrontmatter
+	}
+}
+
+/**
+ * Close an issue
+ */
+export async function closeIssue(id: string): Promise<Issue> {
+	return updateIssue(id, { status: 'closed' })
+}
+
+/**
+ * Reopen an issue
+ */
+export async function reopenIssue(id: string): Promise<Issue> {
+	return updateIssue(id, { status: 'open' })
+}
+
+/**
+ * Delete an issue permanently
+ */
+export async function deleteIssue(id: string): Promise<void> {
+	const issue = await getIssue(id)
+
+	if (!issue) {
+		throw new Error(`Issue not found: ${id}`)
+	}
+
+	const { unlink } = await import('node:fs/promises')
+	await unlink(join(getIssuesDir(), issue.filename))
+}

package/src/lib/query-parser.ts

@@ -0,0 +1,131 @@
+/**
+ * Query language parser for issues explorer
+ *
+ * Parses GitHub-style query syntax to extract qualifiers and free text.
+ * Example: "is:open priority:high dashboard" -> { qualifiers: { is: "open", priority: "high" }, searchText: "dashboard" }
+ */
+
+/**
+ * Parsed query result containing extracted qualifiers and search text
+ */
+export interface ParsedQuery {
+	qualifiers: Record<string, string>
+	searchText: string
+}
+
+/**
+ * Supported qualifier keys
+ */
+const SUPPORTED_QUALIFIERS = new Set([
+	'is',
+	'priority',
+	'type',
+	'label',
+	'sort'
+])
+
+/**
+ * Parse a query string into qualifiers and free text
+ *
+ * @param query - The query string to parse (e.g., "is:open priority:high dashboard")
+ * @returns Parsed query with qualifiers object and search text string
+ *
+ * @example
+ * parseQuery("is:open priority:high dashboard")
+ * // { qualifiers: { is: "open", priority: "high" }, searchText: "dashboard" }
+ *
+ * @example
+ * parseQuery("type:bug label:frontend k8s cluster")
+ * // { qualifiers: { type: "bug", label: "frontend" }, searchText: "k8s cluster" }
+ *
+ * @example
+ * parseQuery("dashboard")
+ * // { qualifiers: {}, searchText: "dashboard" }
+ *
+ * @example
+ * parseQuery("is:open")
+ * // { qualifiers: { is: "open" }, searchText: "" }
+ */
+export function parseQuery(query: string): ParsedQuery {
+	const qualifiers: Record<string, string> = {}
+	const searchTextParts: string[] = []
+
+	if (!query || !query.trim()) {
+		return { qualifiers, searchText: '' }
+	}
+
+	// Split by spaces, but preserve quoted strings
+	const tokens = tokenizeQuery(query)
+
+	for (const token of tokens) {
+		// Check if token matches key:value pattern
+		const colonIndex = token.indexOf(':')
+
+		if (colonIndex > 0 && colonIndex < token.length - 1) {
+			const key = token.substring(0, colonIndex)
+			const value = token.substring(colonIndex + 1)
+
+			// Only extract if it's a supported qualifier
+			// Unknown qualifiers are treated as search text
+			if (SUPPORTED_QUALIFIERS.has(key)) {
+				qualifiers[key] = value
+			} else {
+				// Unknown qualifier format - treat as search text
+				searchTextParts.push(token)
+			}
+		} else {
+			// No colon or invalid format - treat as search text
+			searchTextParts.push(token)
+		}
+	}
+
+	return {
+		qualifiers,
+		searchText: searchTextParts.join(' ').trim()
+	}
+}
+
+/**
+ * Tokenize a query string, handling quoted strings
+ *
+ * @param query - The query string to tokenize
+ * @returns Array of tokens
+ */
+function tokenizeQuery(query: string): string[] {
+	const tokens: string[] = []
+	let currentToken = ''
+	let inQuotes = false
+	let quoteChar = ''
+
+	for (let i = 0; i < query.length; i++) {
+		const char = query[i]
+
+		if ((char === '"' || char === "'") && !inQuotes) {
+			// Start of quoted string
+			inQuotes = true
+			quoteChar = char
+			// Don't include the quote in the token
+		} else if (char === quoteChar && inQuotes) {
+			// End of quoted string
+			inQuotes = false
+			quoteChar = ''
+			// Don't include the quote in the token
+		} else if (char === ' ' && !inQuotes) {
+			// Space outside quotes - end of token
+			if (currentToken) {
+				tokens.push(currentToken)
+				currentToken = ''
+			}
+		} else {
+			// Regular character - add to current token
+			currentToken += char
+		}
+	}
+
+	// Add final token if exists
+	if (currentToken) {
+		tokens.push(currentToken)
+	}
+
+	return tokens
+}

package/src/lib/search.ts

@@ -0,0 +1,349 @@
+/**
+ * Fuzzy search functionality for issues using Fuse.js
+ */
+
+import Fuse, { type IFuseOptions } from 'fuse.js'
+import type { Issue, IssueFilters } from './types'
+import { parseQuery, type ParsedQuery } from './query-parser'
+
+// Fuse.js configuration for fuzzy search
+const FUSE_OPTIONS: IFuseOptions<Issue> = {
+	keys: [
+		{ name: 'frontmatter.title', weight: 1.0 },
+		{ name: 'frontmatter.description', weight: 0.7 },
+		{ name: 'frontmatter.labels', weight: 0.5 },
+		{ name: 'content', weight: 0.3 }
+	],
+	threshold: 0.4, // 0 = exact match, 1 = match anything
+	ignoreLocation: true, // search entire string, not just beginning
+	includeScore: true
+}
+
+/**
+ * Create a Fuse.js instance for searching issues
+ */
+export function createSearchIndex(issues: Issue[]): Fuse<Issue> {
+	return new Fuse(issues, FUSE_OPTIONS)
+}
+
+/**
+ * Search issues with fuzzy matching
+ * Returns issues sorted by relevance
+ */
+export function searchIssues(fuse: Fuse<Issue>, query: string): Issue[] {
+	if (!query.trim()) {
+		return []
+	}
+
+	const results = fuse.search(query)
+	return results.map(r => r.item)
+}
+
+/**
+ * Filter issues by frontmatter fields
+ */
+export function filterIssues(issues: Issue[], filters: IssueFilters): Issue[] {
+	return issues.filter(issue => {
+		if (filters.status && issue.frontmatter.status !== filters.status) {
+			return false
+		}
+		if (
+			filters.priority &&
+			issue.frontmatter.priority !== filters.priority
+		) {
+			return false
+		}
+		if (filters.type && issue.frontmatter.type !== filters.type) {
+			return false
+		}
+		return true
+	})
+}
+
+/**
+ * Filter and search issues
+ * Applies filters first, then fuzzy search if query provided
+ * ID matches (exact prefix) are ranked first
+ */
+export function filterAndSearchIssues(
+	issues: Issue[],
+	filters: IssueFilters
+): Issue[] {
+	// First apply dropdown filters
+	let result = filterIssues(issues, filters)
+
+	// Then apply fuzzy search if there's a search term
+	if (filters.search?.trim()) {
+		const query = filters.search.trim()
+
+		// Check for ID matches first (exact prefix match)
+		// Supports: "1" -> "0001", "01" -> "0001", "0001" -> "0001"
+		const idMatches: Issue[] = []
+		const nonIdMatches: Issue[] = []
+
+		const normalizedQuery = query.replace(/^0+/, '') // Remove leading zeros
+
+		for (const issue of result) {
+			const normalizedId = issue.id.replace(/^0+/, '')
+			if (
+				normalizedId.startsWith(normalizedQuery) ||
+				issue.id.startsWith(query)
+			) {
+				idMatches.push(issue)
+			}
+		}
+
+		// Now do fuzzy search
+		const fuse = createSearchIndex(issues)
+		const searchResults = fuse.search(query)
+		const matchedIds = new Set(searchResults.map(r => r.item.id))
+
+		// Get fuzzy matches that aren't already ID matches
+		const idMatchSet = new Set(idMatches.map(i => i.id))
+		for (const issue of result) {
+			if (!idMatchSet.has(issue.id) && matchedIds.has(issue.id)) {
+				nonIdMatches.push(issue)
+			}
+		}
+
+		// Sort fuzzy matches by relevance
+		nonIdMatches.sort((a, b) => {
+			const aScore =
+				searchResults.find(r => r.item.id === a.id)?.score ?? 1
+			const bScore =
+				searchResults.find(r => r.item.id === b.id)?.score ?? 1
+			return aScore - bScore // Lower score = better match
+		})
+
+		// ID matches first, then fuzzy matches
+		result = [...idMatches, ...nonIdMatches]
+	}
+
+	return result
+}
+
+/**
+ * Sort issues by the specified sort option
+ *
+ * @param issues - Array of issues to sort (modified in place)
+ * @param sortBy - Sort option: "priority", "created", "updated", or "id"
+ */
+function sortIssues(issues: Issue[], sortBy: string): void {
+	const sortOption = sortBy.toLowerCase()
+
+	if (sortOption === 'priority') {
+		// Sort by priority (high → medium → low), then by ID (newest first)
+		const priorityOrder: Record<string, number> = {
+			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) // newest first within priority
+		})
+	} else if (sortOption === 'created') {
+		// Sort by creation date (newest first)
+		issues.sort((a, b) => {
+			const dateA = a.frontmatter.created || ''
+			const dateB = b.frontmatter.created || ''
+			if (dateA !== dateB) return dateB.localeCompare(dateA) // newest first
+			return b.id.localeCompare(a.id) // fallback to ID
+		})
+	} else if (sortOption === 'created-asc') {
+		// Sort by creation date (oldest first)
+		issues.sort((a, b) => {
+			const dateA = a.frontmatter.created || ''
+			const dateB = b.frontmatter.created || ''
+			if (dateA !== dateB) return dateA.localeCompare(dateB) // oldest first
+			return a.id.localeCompare(b.id) // fallback to ID
+		})
+	} else if (sortOption === 'updated') {
+		// Sort by last updated date (most recent first), fallback to created if no 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) // newest first
+			return b.id.localeCompare(a.id) // fallback to ID
+		})
+	} else if (sortOption === 'id') {
+		// Sort by issue ID (newest first)
+		issues.sort((a, b) => b.id.localeCompare(a.id))
+	} else {
+		// Invalid sort option - default to priority sort
+		const priorityOrder: Record<string, number> = {
+			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) // newest first within priority
+		})
+	}
+}
+
+/**
+ * Filter issues using parsed query qualifiers and fuzzy search
+ *
+ * Supports the following qualifiers:
+ * - `is:open` / `is:closed` - filters by status
+ * - `priority:high` / `priority:medium` / `priority:low` - filters by priority
+ * - `type:bug` / `type:improvement` - filters by type
+ * - `label:x` - filters by label (case-insensitive partial match)
+ * - `sort:priority` / `sort:created` / `sort:created-asc` / `sort:updated` / `sort:id` - sorts results
+ *
+ * Any remaining free text after qualifiers triggers fuzzy search across title,
+ * description, labels, and content. Results are sorted by relevance when search
+ * text is present. When no search text is provided, results are sorted by the
+ * `sort:` qualifier (defaults to priority if not specified). ID prefix matching
+ * is supported (e.g., "1" matches #0001).
+ *
+ * Invalid qualifier values are ignored (issue passes filter).
+ * Multiple qualifiers use AND logic (all must match).
+ *
+ * @param issues - Array of issues to filter
+ * @param query - Query string containing qualifiers and/or search text (e.g., "is:open dashboard")
+ * @returns Filtered array of issues matching all qualifiers and search text
+ *
+ * @example
+ * filterByQuery(issues, "is:open")
+ * // Returns only open issues, sorted by priority (default)
+ *
+ * @example
+ * filterByQuery(issues, "is:open sort:created")
+ * // Returns only open issues, sorted by creation date (newest first)
+ *
+ * @example
+ * filterByQuery(issues, "is:open priority:high type:bug")
+ * // Returns only open, high priority bugs, sorted by priority (default)
+ *
+ * @example
+ * filterByQuery(issues, "label:frontend sort:updated")
+ * // Returns only issues with "frontend" in their labels, sorted by update date
+ *
+ * @example
+ * filterByQuery(issues, "dashboard")
+ * // Returns issues matching "dashboard" via fuzzy search, sorted by relevance
+ *
+ * @example
+ * filterByQuery(issues, "is:open dashboard")
+ * // Returns open issues matching "dashboard" via fuzzy search, sorted by relevance
+ */
+export function filterByQuery(issues: Issue[], query: string): Issue[] {
+	const parsed = parseQuery(query)
+
+	// First, filter by qualifiers
+	let result = issues.filter(issue => {
+		// is: qualifier (maps to status)
+		if (parsed.qualifiers.is) {
+			const statusValue = parsed.qualifiers.is.toLowerCase()
+			// Only filter if value is valid (open or closed)
+			if (statusValue === 'open' || statusValue === 'closed') {
+				if (issue.frontmatter.status !== statusValue) {
+					return false
+				}
+			}
+			// Invalid values are ignored (issue passes filter)
+		}
+
+		// priority: qualifier
+		if (parsed.qualifiers.priority) {
+			const priorityValue = parsed.qualifiers.priority.toLowerCase()
+			// Only filter if value is valid (high, medium, or low)
+			if (
+				priorityValue === 'high' ||
+				priorityValue === 'medium' ||
+				priorityValue === 'low'
+			) {
+				if (issue.frontmatter.priority !== priorityValue) {
+					return false
+				}
+			}
+			// Invalid values are ignored (issue passes filter)
+		}
+
+		// type: qualifier
+		if (parsed.qualifiers.type) {
+			const typeValue = parsed.qualifiers.type.toLowerCase()
+			// Only filter if value is valid (bug or improvement)
+			if (typeValue === 'bug' || typeValue === 'improvement') {
+				if (issue.frontmatter.type !== typeValue) {
+					return false
+				}
+			}
+			// Invalid values are ignored (issue passes filter)
+		}
+
+		// label: qualifier
+		if (parsed.qualifiers.label) {
+			const labelQuery = parsed.qualifiers.label.toLowerCase()
+			const issueLabels = (issue.frontmatter.labels || '').toLowerCase()
+			// Check if the label query appears in the issue's labels (partial match)
+			if (!issueLabels.includes(labelQuery)) {
+				return false
+			}
+		}
+
+		return true
+	})
+
+	// Apply sorting if no search text (search text uses relevance sorting)
+	if (!parsed.searchText.trim()) {
+		const sortBy = parsed.qualifiers.sort?.toLowerCase() || 'priority'
+		sortIssues(result, sortBy)
+	}
+
+	// If there's search text, apply fuzzy search
+	if (parsed.searchText.trim()) {
+		const searchQuery = parsed.searchText.trim()
+
+		// Check for ID matches first (exact prefix match)
+		// Supports: "1" -> "0001", "01" -> "0001", "0001" -> "0001"
+		const idMatches: Issue[] = []
+		const nonIdMatches: Issue[] = []
+
+		const normalizedQuery = searchQuery.replace(/^0+/, '') // Remove leading zeros
+
+		for (const issue of result) {
+			const normalizedId = issue.id.replace(/^0+/, '')
+			if (
+				normalizedId.startsWith(normalizedQuery) ||
+				issue.id.startsWith(searchQuery)
+			) {
+				idMatches.push(issue)
+			}
+		}
+
+		// Now do fuzzy search on the filtered results
+		const fuse = createSearchIndex(result)
+		const searchResults = fuse.search(searchQuery)
+		const matchedIds = new Set(searchResults.map(r => r.item.id))
+
+		// Get fuzzy matches that aren't already ID matches
+		const idMatchSet = new Set(idMatches.map(i => i.id))
+		for (const issue of result) {
+			if (!idMatchSet.has(issue.id) && matchedIds.has(issue.id)) {
+				nonIdMatches.push(issue)
+			}
+		}
+
+		// Sort fuzzy matches by relevance
+		nonIdMatches.sort((a, b) => {
+			const aScore =
+				searchResults.find(r => r.item.id === a.id)?.score ?? 1
+			const bScore =
+				searchResults.find(r => r.item.id === b.id)?.score ?? 1
+			return aScore - bScore // Lower score = better match
+		})
+
+		// ID matches first, then fuzzy matches
+		result = [...idMatches, ...nonIdMatches]
+	}
+
+	return result
+}

package/src/lib/types.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared types for the issue tracking system
+ */
+
+export interface IssueFrontmatter {
+  title: string;
+  description: string;
+  priority: "high" | "medium" | "low";
+  type: "bug" | "improvement";
+  labels?: string;
+  status: "open" | "closed";
+  created: string;
+  updated?: string;
+}
+
+export interface Issue {
+  id: string;
+  filename: string;
+  frontmatter: IssueFrontmatter;
+  content: string;
+}
+
+export interface IssueFilters {
+  status?: string;
+  priority?: string;
+  type?: string;
+  search?: string;
+}
+
+export interface CreateIssueInput {
+  title: string;
+  description?: string;
+  priority?: "high" | "medium" | "low";
+  type?: "bug" | "improvement";
+  labels?: string;
+}
+
+export interface UpdateIssueInput {
+  title?: string;
+  description?: string;
+  priority?: "high" | "medium" | "low";
+  type?: "bug" | "improvement";
+  labels?: string;
+  status?: "open" | "closed";
+}