@miketromba/issy-core 0.5.6 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miketromba/issy-core",
-  "version": "0.5.6",
+  "version": "0.6.0",
   "description": "Issue storage, search, and parsing for issy",
   "type": "module",
   "license": "MIT",

package/src/lib/autocomplete.ts

@@ -9,36 +9,36 @@
  * 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
+	/** 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',
-  'scope',
-  'type',
-  'label',
-  'sort',
+	'is',
+	'priority',
+	'scope',
+	'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,
-  scope: ['small', 'medium', 'large'] as const,
-  type: ['bug', 'improvement'] as const,
-  sort: ['roadmap', 'priority', 'scope', 'created', 'updated', 'id'] as const,
-  // label values are dynamic and provided via existingLabels parameter
+	is: ['open', 'closed'] as const,
+	priority: ['high', 'medium', 'low'] as const,
+	scope: ['small', 'medium', 'large'] as const,
+	type: ['bug', 'improvement'] as const,
+	sort: ['roadmap', 'priority', 'scope', 'created', 'updated', 'id'] as const
+	// label values are dynamic and provided via existingLabels parameter
 }
 
 /**
@@ -58,185 +58,189 @@ const QUALIFIER_VALUES: Record<string, readonly string[]> = {
  * // [{ text: "priority:", displayText: "priority:", description: "Filter by priority" }, ...]
  */
 export function getQuerySuggestions(
-  query: string,
-  cursorPosition?: number,
-  existingLabels?: string[],
+	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 } = 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 as readonly string[]).includes(qualifierKey)) {
-      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 []
+	// 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 } = 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 as readonly string[]).includes(qualifierKey)) {
+			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[],
+	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),
-  }))
+	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
+	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 }
+	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
-  }
+	if (!text || text.trim() === '') {
+		return null
+	}
 
-  const tokens = text.trim().split(/\s+/)
-  if (tokens.length < 2) {
-    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 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',
-    scope: 'Filter by scope',
-    type: 'Filter by type',
-    label: 'Filter by label',
-    sort: 'Sort results',
-  }
-  return descriptions[key] || ''
+	const descriptions: Record<string, string> = {
+		is: 'Filter by status',
+		priority: 'Filter by priority',
+		scope: 'Filter by scope',
+		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 === 'scope') {
-    return `Scope: ${value}`
-  }
-  if (key === 'type') {
-    return value === 'bug' ? 'Bug report' : 'Improvement'
-  }
-  if (key === 'sort') {
-    return `Sort by ${value}`
-  }
-  return ''
+	if (key === 'is') {
+		return value === 'open' ? 'Open issues' : 'Closed issues'
+	}
+	if (key === 'priority') {
+		return `Priority: ${value}`
+	}
+	if (key === 'scope') {
+		return `Scope: ${value}`
+	}
+	if (key === 'type') {
+		return value === 'bug' ? 'Bug report' : 'Improvement'
+	}
+	if (key === 'sort') {
+		return `Sort by ${value}`
+	}
+	return ''
 }

package/src/lib/browser.ts

@@ -15,9 +15,9 @@ export { filterByQuery, filterIssues } from './search'
 
 // Types
 export type {
-  CreateIssueInput,
-  Issue,
-  IssueFilters,
-  IssueFrontmatter,
-  UpdateIssueInput,
+	CreateIssueInput,
+	Issue,
+	IssueFilters,
+	IssueFrontmatter,
+	UpdateIssueInput
 } from './types'

package/src/lib/formatDate.ts

@@ -5,59 +5,59 @@ import { format, formatDistanceToNow, isValid, parseISO } from 'date-fns'
  * 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
-  }
+	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
-  }
+	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

@@ -12,55 +12,55 @@ export { getQuerySuggestions } from './autocomplete'
 export { formatDisplayDate, formatFullDate } from './formatDate'
 // Core issue operations
 export {
-  autoDetectIssuesDir,
-  closeIssue,
-  computeOrderKey,
-  createIssue,
-  createSlug,
-  deleteIssue,
-  ensureIssuesDir,
-  findGitRoot,
-  findIssuesDirUpward,
-  findIssyDirUpward,
-  findLegacyIssuesDirUpward,
-  formatDate,
-  generateBatchOrderKeys,
-  generateFrontmatter,
-  getAllIssues,
-  getIssue,
-  getIssueFiles,
-  getIssueIdFromFilename,
-  getIssuesDir,
-  getIssyDir,
-  getNextIssue,
-  getNextIssueNumber,
-  getOnCloseContent,
-  getOpenIssuesByOrder,
-  hasLegacyIssuesDir,
-  parseFrontmatter,
-  reopenIssue,
-  resolveIssuesDir,
-  resolveIssyDir,
-  setIssuesDir,
-  setIssyDir,
-  updateIssue,
+	autoDetectIssuesDir,
+	closeIssue,
+	computeOrderKey,
+	createIssue,
+	createSlug,
+	deleteIssue,
+	ensureIssuesDir,
+	findGitRoot,
+	findIssuesDirUpward,
+	findIssyDirUpward,
+	findLegacyIssuesDirUpward,
+	formatDate,
+	generateBatchOrderKeys,
+	generateFrontmatter,
+	getAllIssues,
+	getIssue,
+	getIssueFiles,
+	getIssueIdFromFilename,
+	getIssuesDir,
+	getIssyDir,
+	getNextIssue,
+	getNextIssueNumber,
+	getOnCloseContent,
+	getOpenIssuesByOrder,
+	hasLegacyIssuesDir,
+	parseFrontmatter,
+	reopenIssue,
+	resolveIssuesDir,
+	resolveIssyDir,
+	setIssuesDir,
+	setIssyDir,
+	updateIssue
 } from './issues'
 // Query parser
 export type { ParsedQuery } from './query-parser'
 export { parseQuery } from './query-parser'
 // Search functionality
 export {
-  createSearchIndex,
-  filterAndSearchIssues,
-  filterByQuery,
-  filterIssues,
-  searchIssues,
+	createSearchIndex,
+	filterAndSearchIssues,
+	filterByQuery,
+	filterIssues,
+	searchIssues
 } from './search'
 // Types
 export type {
-  CreateIssueInput,
-  Issue,
-  IssueFilters,
-  IssueFrontmatter,
-  UpdateIssueInput,
+	CreateIssueInput,
+	Issue,
+	IssueFilters,
+	IssueFrontmatter,
+	UpdateIssueInput
 } from './types'