@sudocode-ai/cli 0.1.0

package/dist/migrations.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Database migration utilities for sudocode
+ */
+import type Database from "better-sqlite3";
+export interface Migration {
+    version: number;
+    name: string;
+    up: (db: Database.Database) => void;
+    down?: (db: Database.Database) => void;
+}
+/**
+ * Get the current migration version from the database
+ */
+export declare function getCurrentMigrationVersion(db: Database.Database): number;
+/**
+ * Record a migration as applied
+ */
+export declare function recordMigration(db: Database.Database, migration: Migration): void;
+/**
+ * Run all pending migrations
+ */
+export declare function runMigrations(db: Database.Database): void;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/operations/events.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Operations for Events (audit trail)
+ */
+import type Database from 'better-sqlite3';
+import type { Event, EntityType, EventType } from '../types.js';
+export interface CreateEventInput {
+    entity_id: string;
+    entity_type: EntityType;
+    event_type: EventType;
+    actor: string;
+    old_value?: string | null;
+    new_value?: string | null;
+    comment?: string | null;
+    git_commit_sha?: string | null;
+    source?: string;
+}
+export interface QueryEventsOptions {
+    entity_id?: string;
+    entity_type?: EntityType;
+    event_type?: EventType;
+    actor?: string;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Insert an event
+ */
+export declare function insertEvent(db: Database.Database, input: CreateEventInput): Event;
+/**
+ * Get an event by ID
+ */
+export declare function getEvent(db: Database.Database, id: number): Event | null;
+/**
+ * Query events with filters
+ */
+export declare function queryEvents(db: Database.Database, options?: QueryEventsOptions): Event[];
+/**
+ * Get all events for a specific entity
+ */
+export declare function getEntityEvents(db: Database.Database, entity_id: string, entity_type: EntityType, limit?: number): Event[];
+/**
+ * Get recent events across all entities
+ */
+export declare function getRecentEvents(db: Database.Database, limit?: number): Event[];
+/**
+ * Get events by actor
+ */
+export declare function getEventsByActor(db: Database.Database, actor: string, limit?: number): Event[];
+/**
+ * Delete events for an entity (cleanup)
+ */
+export declare function deleteEntityEvents(db: Database.Database, entity_id: string, entity_type: EntityType): number;
+//# sourceMappingURL=events.d.ts.map

package/dist/operations/feedback-anchors.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Feedback anchor creation and manipulation utilities
+ */
+import type { FeedbackAnchor } from '../types.js';
+export interface SectionInfo {
+    heading: string;
+    level: number;
+    startLine: number;
+}
+/**
+ * Create a feedback anchor at a specific line in spec content
+ */
+export declare function createFeedbackAnchor(specContent: string, lineNumber: number, charOffset?: number): FeedbackAnchor;
+/**
+ * Create a feedback anchor by searching for text in spec content
+ */
+export declare function createAnchorByText(specContent: string, searchText: string): FeedbackAnchor | null;
+/**
+ * Find the section (markdown heading) containing a given line
+ * Walks backwards from the line to find the nearest heading
+ */
+export declare function findContainingSection(lines: string[], lineNumber: number): SectionInfo | null;
+/**
+ * Extract a text snippet from a line with optional character offset
+ */
+export declare function extractSnippet(line: string, charOffset?: number, maxLength?: number): string;
+/**
+ * Get context around a line (before or after)
+ * @param chars Number of characters to get (negative for before, positive for after)
+ */
+export declare function getContext(lines: string[], fromLine: number, chars: number): string;
+/**
+ * Create a content hash for quick validation
+ */
+export declare function createContentHash(content: string): string;
+/**
+ * Verify that an anchor still points to the expected location
+ */
+export declare function verifyAnchor(specContent: string, anchor: FeedbackAnchor): boolean;
+/**
+ * Get all section headings from spec content
+ */
+export declare function getAllSections(specContent: string): SectionInfo[];
+/**
+ * Search for text with context matching
+ * Returns all matching locations with confidence scores
+ */
+export declare function searchByContent(specContent: string, snippet?: string, contextBefore?: string, contextAfter?: string): Array<{
+    lineNumber: number;
+    confidence: number;
+}>;
+/**
+ * Calculate Levenshtein distance between two strings
+ * Used for fuzzy matching of section headings
+ */
+export declare function levenshteinDistance(str1: string, str2: string): number;
+/**
+ * Find the best matching section using fuzzy matching
+ * Returns section with lowest edit distance (Levenshtein)
+ */
+export declare function findFuzzySection(specContent: string, targetHeading: string, maxDistance?: number): SectionInfo | null;
+/**
+ * Relocate a feedback anchor when spec content changes
+ * Uses cascade strategy:
+ * 1. Section + Line Offset (if section unchanged)
+ * 2. Content Search (snippet + context)
+ * 3. Fuzzy Section Match (Levenshtein distance)
+ * 4. Mark as Stale (preserve original)
+ */
+export declare function relocateFeedbackAnchor(oldSpecContent: string, newSpecContent: string, anchor: FeedbackAnchor): FeedbackAnchor;
+/**
+ * Relocate all feedback anchors for a spec when its content changes
+ * Returns summary of relocation results
+ */
+export interface RelocationResult {
+    feedback_id: string;
+    old_status: 'valid' | 'relocated' | 'stale';
+    new_status: 'valid' | 'relocated' | 'stale';
+    relocated: boolean;
+}
+export interface RelocationSummary {
+    total: number;
+    valid: number;
+    relocated: number;
+    stale: number;
+    results: RelocationResult[];
+}
+export declare function relocateSpecFeedback(oldSpecContent: string, newSpecContent: string, feedbackList: Array<{
+    id: string;
+    anchor: FeedbackAnchor;
+}>): RelocationSummary;
+//# sourceMappingURL=feedback-anchors.d.ts.map

package/dist/operations/feedback.d.ts

@@ -0,0 +1,76 @@
+/**
+ * CRUD operations for Issue Feedback
+ */
+import type Database from "better-sqlite3";
+import type { IssueFeedback, FeedbackType, FeedbackAnchor } from "../types.js";
+export interface CreateFeedbackInput {
+    id?: string;
+    issue_id: string;
+    spec_id: string;
+    feedback_type: FeedbackType;
+    content: string;
+    agent?: string;
+    anchor?: FeedbackAnchor;
+    dismissed?: boolean;
+}
+export interface UpdateFeedbackInput {
+    content?: string;
+    dismissed?: boolean;
+    anchor?: FeedbackAnchor;
+}
+export interface ListFeedbackOptions {
+    issue_id?: string;
+    spec_id?: string;
+    feedback_type?: FeedbackType;
+    dismissed?: boolean;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Generate next feedback ID (FB-001, FB-002, etc.)
+ */
+export declare function generateFeedbackId(db: Database.Database): string;
+/**
+ * Create a new feedback entry
+ */
+export declare function createFeedback(db: Database.Database, input: CreateFeedbackInput): IssueFeedback;
+/**
+ * Get a feedback entry by ID
+ */
+export declare function getFeedback(db: Database.Database, id: string): IssueFeedback | null;
+/**
+ * Update a feedback entry
+ */
+export declare function updateFeedback(db: Database.Database, id: string, input: UpdateFeedbackInput): IssueFeedback;
+/**
+ * Delete a feedback entry
+ */
+export declare function deleteFeedback(db: Database.Database, id: string): boolean;
+/**
+ * Dismiss feedback (convenience method)
+ */
+export declare function dismissFeedback(db: Database.Database, id: string): IssueFeedback;
+/**
+ * List feedback entries with optional filters
+ */
+export declare function listFeedback(db: Database.Database, options?: ListFeedbackOptions): IssueFeedback[];
+/**
+ * Get all feedback for a specific issue
+ */
+export declare function getFeedbackForIssue(db: Database.Database, issue_id: string): IssueFeedback[];
+/**
+ * Get all feedback for a specific spec
+ */
+export declare function getFeedbackForSpec(db: Database.Database, spec_id: string): IssueFeedback[];
+/**
+ * Get active feedback for a spec (not dismissed)
+ */
+export declare function getActiveFeedbackForSpec(db: Database.Database, spec_id: string): IssueFeedback[];
+/**
+ * Count feedback by dismissed status
+ */
+export declare function countFeedbackByDismissed(db: Database.Database, spec_id?: string): {
+    active: number;
+    dismissed: number;
+};
+//# sourceMappingURL=feedback.d.ts.map

package/dist/operations/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Main entry point for all database operations
+ */
+export * from './specs.js';
+export * from './issues.js';
+export * from './relationships.js';
+export * from './tags.js';
+export * from './events.js';
+export * from './references.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/operations/issues.d.ts

@@ -0,0 +1,82 @@
+/**
+ * CRUD operations for Issues
+ */
+import type Database from "better-sqlite3";
+import type { Issue, IssueStatus } from "../types.js";
+export interface CreateIssueInput {
+    id: string;
+    uuid?: string;
+    title: string;
+    content?: string;
+    status?: IssueStatus;
+    priority?: number;
+    assignee?: string;
+    parent_id?: string;
+    archived?: boolean;
+    archived_at?: string;
+    created_at?: string;
+    updated_at?: string;
+    closed_at?: string;
+}
+export interface UpdateIssueInput {
+    title?: string;
+    content?: string;
+    status?: IssueStatus;
+    priority?: number;
+    assignee?: string;
+    parent_id?: string;
+    archived?: boolean;
+    archived_at?: string;
+    updated_at?: string;
+    closed_at?: string;
+}
+export interface ListIssuesOptions {
+    status?: IssueStatus;
+    priority?: number;
+    assignee?: string;
+    parent_id?: string;
+    archived?: boolean;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Create a new issue
+ */
+export declare function createIssue(db: Database.Database, input: CreateIssueInput): Issue;
+/**
+ * Get an issue by ID
+ */
+export declare function getIssue(db: Database.Database, id: string): Issue | null;
+/**
+ * Update an issue
+ */
+export declare function updateIssue(db: Database.Database, id: string, input: UpdateIssueInput): Issue;
+/**
+ * Delete an issue
+ */
+export declare function deleteIssue(db: Database.Database, id: string): boolean;
+/**
+ * Close an issue (convenience method)
+ */
+export declare function closeIssue(db: Database.Database, id: string): Issue;
+/**
+ * Reopen an issue (convenience method)
+ */
+export declare function reopenIssue(db: Database.Database, id: string): Issue;
+/**
+ * List issues with optional filters
+ */
+export declare function listIssues(db: Database.Database, options?: ListIssuesOptions): Issue[];
+/**
+ * Get ready issues (no blockers)
+ */
+export declare function getReadyIssues(db: Database.Database): Issue[];
+/**
+ * Get blocked issues
+ */
+export declare function getBlockedIssues(db: Database.Database): any[];
+/**
+ * Search issues by title or content
+ */
+export declare function searchIssues(db: Database.Database, query: string, options?: Omit<ListIssuesOptions, "offset">): Issue[];
+//# sourceMappingURL=issues.d.ts.map

package/dist/operations/references.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Operations for managing cross-references in markdown content
+ */
+export interface AddReferenceOptions {
+    referenceId: string;
+    displayText?: string;
+    relationshipType?: string;
+    format?: 'inline' | 'newline';
+    position?: 'before' | 'after';
+}
+export interface ReferenceLocation {
+    line?: number;
+    text?: string;
+}
+/**
+ * Format a reference string with optional display text and relationship type
+ *
+ * Examples:
+ * - formatReference('issue-001') => '[[issue-001]]'
+ * - formatReference('issue-001', 'OAuth') => '[[issue-001|OAuth]]'
+ * - formatReference('issue-001', undefined, 'implements') => '[[issue-001]]{ implements }'
+ * - formatReference('issue-001', 'OAuth', 'implements') => '[[issue-001|OAuth]]{ implements }'
+ */
+export declare function formatReference(referenceId: string, displayText?: string, relationshipType?: string): string;
+/**
+ * Add a reference to markdown content at the specified location
+ *
+ * @param content - The markdown content to modify
+ * @param location - Where to insert the reference (line or text)
+ * @param options - Reference formatting options
+ * @returns Updated content with reference inserted
+ */
+export declare function addReferenceToContent(content: string, location: ReferenceLocation, options: AddReferenceOptions): string;
+//# sourceMappingURL=references.d.ts.map

package/dist/operations/relationships.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Operations for Relationships
+ */
+import type Database from "better-sqlite3";
+import type { Relationship, EntityType, RelationshipType } from "../types.js";
+export interface CreateRelationshipInput {
+    from_id: string;
+    from_type: EntityType;
+    to_id: string;
+    to_type: EntityType;
+    relationship_type: RelationshipType;
+    metadata?: string;
+}
+/**
+ * Add a relationship between entities
+ */
+export declare function addRelationship(db: Database.Database, input: CreateRelationshipInput): Relationship;
+/**
+ * Get a specific relationship
+ */
+export declare function getRelationship(db: Database.Database, from_id: string, from_type: EntityType, to_id: string, to_type: EntityType, relationship_type: RelationshipType): Relationship | null;
+/**
+ * Remove a relationship
+ */
+export declare function removeRelationship(db: Database.Database, from_id: string, from_type: EntityType, to_id: string, to_type: EntityType, relationship_type: RelationshipType): boolean;
+/**
+ * Get all outgoing relationships from an entity
+ */
+export declare function getOutgoingRelationships(db: Database.Database, entity_id: string, entity_type: EntityType, relationship_type?: RelationshipType): Relationship[];
+/**
+ * Get all incoming relationships to an entity
+ */
+export declare function getIncomingRelationships(db: Database.Database, entity_id: string, entity_type: EntityType, relationship_type?: RelationshipType): Relationship[];
+/**
+ * Get all dependencies (what this entity depends on - things that block it)
+ */
+export declare function getDependencies(db: Database.Database, entity_id: string, entity_type: EntityType): Relationship[];
+/**
+ * Get all dependents (what depends on this entity - things it blocks)
+ */
+export declare function getDependents(db: Database.Database, entity_id: string, entity_type: EntityType): Relationship[];
+/**
+ * Get all relationships for an entity (both incoming and outgoing)
+ */
+export declare function getAllRelationships(db: Database.Database, entity_id: string, entity_type: EntityType): {
+    outgoing: Relationship[];
+    incoming: Relationship[];
+};
+/**
+ * Check if a relationship exists
+ */
+export declare function relationshipExists(db: Database.Database, from_id: string, from_type: EntityType, to_id: string, to_type: EntityType, relationship_type: RelationshipType): boolean;
+/**
+ * Remove all relationships for an entity
+ */
+export declare function removeAllRelationships(db: Database.Database, entity_id: string, entity_type: EntityType): number;
+//# sourceMappingURL=relationships.d.ts.map

package/dist/operations/specs.d.ts

@@ -0,0 +1,64 @@
+/**
+ * CRUD operations for Specs
+ */
+import type Database from "better-sqlite3";
+import type { Spec } from "../types.js";
+export interface CreateSpecInput {
+    id: string;
+    uuid?: string;
+    title: string;
+    file_path: string;
+    content?: string;
+    priority?: number;
+    parent_id?: string;
+    archived?: boolean;
+    archived_at?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface UpdateSpecInput {
+    title?: string;
+    file_path?: string;
+    content?: string;
+    priority?: number;
+    parent_id?: string;
+    archived?: boolean;
+    archived_at?: string;
+    updated_at?: string;
+}
+export interface ListSpecsOptions {
+    priority?: number;
+    parent_id?: string;
+    archived?: boolean;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Create a new spec
+ */
+export declare function createSpec(db: Database.Database, input: CreateSpecInput): Spec;
+/**
+ * Get a spec by ID
+ */
+export declare function getSpec(db: Database.Database, id: string): Spec | null;
+/**
+ * Get a spec by file path
+ */
+export declare function getSpecByFilePath(db: Database.Database, filePath: string): Spec | null;
+/**
+ * Update a spec
+ */
+export declare function updateSpec(db: Database.Database, id: string, input: UpdateSpecInput): Spec;
+/**
+ * Delete a spec
+ */
+export declare function deleteSpec(db: Database.Database, id: string): boolean;
+/**
+ * List specs with optional filters
+ */
+export declare function listSpecs(db: Database.Database, options?: ListSpecsOptions): Spec[];
+/**
+ * Search specs by title or content
+ */
+export declare function searchSpecs(db: Database.Database, query: string, options?: Omit<ListSpecsOptions, "offset">): Spec[];
+//# sourceMappingURL=specs.d.ts.map

package/dist/operations/tags.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Operations for Tags
+ */
+import type Database from "better-sqlite3";
+import type { Tag, EntityType } from "../types.js";
+/**
+ * Add a tag to an entity
+ */
+export declare function addTag(db: Database.Database, entity_id: string, entity_type: EntityType, tag: string): Tag;
+/**
+ * Add multiple tags to an entity
+ */
+export declare function addTags(db: Database.Database, entity_id: string, entity_type: EntityType, tags: string[]): Tag[];
+/**
+ * Remove a tag from an entity
+ */
+export declare function removeTag(db: Database.Database, entity_id: string, entity_type: EntityType, tag: string): boolean;
+/**
+ * Get all tags for an entity
+ */
+export declare function getTags(db: Database.Database, entity_id: string, entity_type: EntityType): string[];
+/**
+ * Get all entities with a specific tag
+ */
+export declare function getEntitiesByTag(db: Database.Database, tag: string, entity_type?: EntityType): Tag[];
+/**
+ * Remove all tags from an entity
+ */
+export declare function removeAllTags(db: Database.Database, entity_id: string, entity_type: EntityType): number;
+/**
+ * Check if an entity has a specific tag
+ */
+export declare function hasTag(db: Database.Database, entity_id: string, entity_type: EntityType, tag: string): boolean;
+/**
+ * Get all unique tags in the system
+ */
+export declare function getAllTags(db: Database.Database, entity_type?: EntityType): string[];
+/**
+ * Replace all tags for an entity
+ */
+export declare function setTags(db: Database.Database, entity_id: string, entity_type: EntityType, tags: string[]): string[];
+//# sourceMappingURL=tags.d.ts.map

package/dist/operations/transactions.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Transaction support with proper error handling
+ */
+import type Database from 'better-sqlite3';
+export type TransactionCallback<T> = (db: Database.Database) => T;
+/**
+ * Execute a function within a transaction
+ * Automatically commits on success, rolls back on error
+ */
+export declare function transaction<T>(db: Database.Database, callback: TransactionCallback<T>): T;
+/**
+ * Execute multiple operations in a transaction
+ * This is a convenience wrapper that handles common patterns
+ */
+export declare function batchTransaction<T>(db: Database.Database, operations: Array<() => T>): T[];
+/**
+ * Execute an operation with automatic retry on busy/locked errors
+ */
+export declare function withRetry<T>(db: Database.Database, operation: TransactionCallback<T>, maxRetries?: number, delayMs?: number): T;
+/**
+ * Savepoint-based nested transaction support
+ */
+export declare class SavepointTransaction {
+    private db;
+    private savepointId;
+    private released;
+    constructor(db: Database.Database, name?: string);
+    /**
+     * Commit the savepoint
+     */
+    commit(): void;
+    /**
+     * Rollback the savepoint
+     */
+    rollback(): void;
+    /**
+     * Execute a callback with automatic commit/rollback
+     */
+    static execute<T>(db: Database.Database, callback: (sp: SavepointTransaction) => T): T;
+}
+//# sourceMappingURL=transactions.d.ts.map

package/dist/sync.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Bidirectional sync between Markdown files and JSONL/SQLite
+ */
+import type Database from "better-sqlite3";
+export interface SyncResult {
+    success: boolean;
+    action: "created" | "updated" | "no-change";
+    entityId: string;
+    entityType: "spec" | "issue";
+    error?: string;
+}
+export interface SyncOptions {
+    /**
+     * Directory for JSONL output (default: .sudocode)
+     */
+    outputDir?: string;
+    /**
+     * Whether to auto-export to JSONL after sync (default: true)
+     */
+    autoExport?: boolean;
+    /**
+     * User performing the sync
+     */
+    user?: string;
+    /**
+     * Auto-initialize missing frontmatter fields (default: true)
+     * If true, generates missing IDs and provides default values
+     * If false, rejects files with missing required fields
+     */
+    autoInitialize?: boolean;
+    /**
+     * Whether to write back initialized frontmatter to the file (default: true)
+     * Only applies when autoInitialize is true
+     */
+    writeBackFrontmatter?: boolean;
+}
+/**
+ * Sync a markdown file to JSONL and SQLite
+ * Parses markdown, updates database, optionally exports to JSONL
+ */
+export declare function syncMarkdownToJSONL(db: Database.Database, mdPath: string, options?: SyncOptions): Promise<SyncResult>;
+/**
+ * Sync from JSONL/SQLite to markdown file
+ * Updates markdown frontmatter while preserving content
+ */
+export declare function syncJSONLToMarkdown(db: Database.Database, entityId: string, entityType: "spec" | "issue", mdPath: string): Promise<SyncResult>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/test-schema.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple test to verify schema initialization
+ */
+export {};
+//# sourceMappingURL=test-schema.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Type definitions for sudocode CLI
+ *
+ * Core entity types are imported from the main sudocode package.
+ */
+export type { Spec, Issue, Relationship, EntityType, RelationshipType, IssueStatus, Tag, Event, EventType, IssueFeedback, LocationAnchor, FeedbackAnchor, FeedbackType, SpecJSONL, IssueJSONL, FeedbackJSONL, RelationshipJSONL, Config, } from "@sudocode-ai/types";
+//# sourceMappingURL=types.d.ts.map

package/dist/update-checker.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Update checker with caching
+ * Checks npm registry for new versions and caches results
+ */
+interface UpdateInfo {
+    current: string;
+    latest: string;
+    updateAvailable: boolean;
+}
+/**
+ * Check for updates
+ * Returns null if check fails or update info if successful
+ */
+export declare function checkForUpdates(): Promise<UpdateInfo | null>;
+/**
+ * Check for updates and return formatted notification message
+ */
+export declare function getUpdateNotification(): Promise<string | null>;
+/**
+ * Clear update cache (useful for testing)
+ */
+export declare function clearUpdateCache(): void;
+export {};
+//# sourceMappingURL=update-checker.d.ts.map

package/dist/version.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Version utilities
+ */
+/**
+ * Get the CLI version from package.json
+ */
+export declare function getVersion(): string;
+/**
+ * The current CLI version
+ */
+export declare const VERSION: string;
+//# sourceMappingURL=version.d.ts.map