@proletariat/cli 0.3.16 → 0.3.18

package/dist/lib/flags/resolver.js

@@ -0,0 +1,313 @@
+/**
+ * FlagResolver - Unified flag resolution for human and machine interactive modes
+ *
+ * This abstraction unifies the two interaction patterns in the CLI:
+ * - Human interactive mode: Uses inquirer prompts, collects input, returns flags
+ * - Machine/JSON mode: Outputs prompt schema as JSON, exits for agent to process
+ *
+ * Both modes use the same underlying pattern: prompts PRODUCE flags.
+ * The execution logic only sees flags, not prompt results.
+ *
+ * @example
+ * ```typescript
+ * // Define prompts for missing flags
+ * const resolver = new FlagResolver({
+ *   commandName: 'ticket create',
+ *   baseCommand: 'prlt ticket create',
+ *   jsonMode: shouldOutputJson(flags),
+ *   flags,
+ * });
+ *
+ * // Add prompts - they execute in order, can depend on previously resolved flags
+ * resolver.addPrompt({
+ *   flagName: 'column',
+ *   type: 'list',
+ *   message: 'Select column:',
+ *   choices: async () => columns.map(c => ({ name: c, value: c })),
+ * });
+ *
+ * resolver.addPrompt({
+ *   flagName: 'title',
+ *   type: 'input',
+ *   message: 'Enter title:',
+ *   when: (ctx) => ctx.flags.column !== undefined, // Only after column is selected
+ * });
+ *
+ * // Resolve all missing flags
+ * const resolved = await resolver.resolve();
+ * // resolved.column and resolved.title are now guaranteed to have values
+ * ```
+ */
+import inquirer from 'inquirer';
+import { outputPromptAsJson, createMetadata, } from '../prompt-json.js';
+/**
+ * FlagResolver handles unified flag resolution for both human and machine modes.
+ *
+ * Usage pattern:
+ * 1. Create resolver with command info and current flags
+ * 2. Add prompt definitions for flags that may need resolution
+ * 3. Call resolve() to get complete flags
+ *
+ * In JSON mode, resolve() outputs the first unresolved prompt and exits.
+ * In interactive mode, resolve() prompts for each unresolved flag sequentially.
+ */
+export class FlagResolver {
+    prompts = [];
+    options;
+    resolvedFlags;
+    resolverContext;
+    constructor(options) {
+        this.options = options;
+        this.resolvedFlags = { ...options.flags };
+        this.resolverContext = {
+            flags: this.resolvedFlags,
+            args: options.args || {},
+            commandName: options.commandName,
+            baseCommand: options.baseCommand,
+            ...options.context,
+        };
+    }
+    /**
+     * Add a prompt definition for resolving a flag.
+     * Prompts are processed in the order they are added.
+     */
+    addPrompt(prompt) {
+        this.prompts.push(prompt);
+        return this;
+    }
+    /**
+     * Add multiple prompt definitions at once.
+     */
+    addPrompts(prompts) {
+        for (const prompt of prompts) {
+            this.prompts.push(prompt);
+        }
+        return this;
+    }
+    /**
+     * Update the context with additional data.
+     * Useful for adding computed values that prompts might need.
+     */
+    setContext(key, value) {
+        this.resolverContext[key] = value;
+        return this;
+    }
+    /**
+     * Get current context value
+     */
+    getContext(key) {
+        return this.resolverContext[key];
+    }
+    /**
+     * Check if a flag has a value (not undefined)
+     */
+    hasFlag(flagName) {
+        return this.resolvedFlags[flagName] !== undefined;
+    }
+    /**
+     * Get current flag value
+     */
+    getFlag(flagName) {
+        return this.resolvedFlags[flagName];
+    }
+    /**
+     * Set a flag value directly (bypasses prompting)
+     */
+    setFlag(flagName, value) {
+        this.resolvedFlags[flagName] = value;
+        this.resolverContext.flags = this.resolvedFlags;
+        return this;
+    }
+    /**
+     * Resolve all prompts and return complete flags.
+     *
+     * In JSON mode: outputs the first unresolved prompt as JSON and exits (never returns).
+     * In interactive mode: prompts for each unresolved flag and returns all flags.
+     *
+     * @returns The fully resolved flags
+     */
+    async resolve() {
+        for (const prompt of this.prompts) {
+            // Check if flag already has a value
+            const currentValue = this.resolvedFlags[prompt.flagName];
+            if (currentValue !== undefined) {
+                continue;
+            }
+            // Check conditional
+            if (prompt.when && !prompt.when(this.resolverContext)) {
+                continue;
+            }
+            // Resolve the message if it's a function
+            const message = typeof prompt.message === 'function'
+                ? prompt.message(this.resolverContext)
+                : prompt.message;
+            // Get choices if applicable
+            let choices;
+            if (prompt.choices) {
+                choices = await Promise.resolve(prompt.choices(this.resolverContext));
+            }
+            // Get default value
+            const defaultValue = typeof prompt.default === 'function'
+                ? prompt.default(this.resolverContext)
+                : prompt.default;
+            if (this.options.jsonMode) {
+                // JSON MODE: Output prompt config and exit
+                await this.outputJsonPrompt(prompt, message, choices, defaultValue);
+                // outputPromptAsJson calls process.exit, so we never reach here
+            }
+            else {
+                // INTERACTIVE MODE: Prompt for value
+                const value = await this.promptInteractive(prompt, message, choices, defaultValue);
+                // Transform value if needed
+                const finalValue = prompt.transform
+                    ? prompt.transform(value, this.resolverContext)
+                    : value;
+                // Store resolved flag
+                this.resolvedFlags[prompt.flagName] = finalValue;
+                this.resolverContext.flags = this.resolvedFlags;
+            }
+        }
+        return this.resolvedFlags;
+    }
+    /**
+     * Output prompt as JSON for machine mode
+     */
+    async outputJsonPrompt(prompt, message, choices, defaultValue) {
+        // Build prompt config
+        const config = {
+            type: prompt.type,
+            name: prompt.flagName,
+            message,
+        };
+        // Add choices with command field
+        if (choices) {
+            config.choices = choices.map(choice => {
+                const promptChoice = {
+                    name: choice.name,
+                    value: String(choice.value),
+                };
+                if (choice.disabled !== undefined) {
+                    promptChoice.disabled = Boolean(choice.disabled);
+                }
+                // Generate command for this choice
+                if (choice.command) {
+                    promptChoice.command = choice.command;
+                }
+                else if (!prompt.skipAutoCommand) {
+                    // Auto-generate command
+                    promptChoice.command = prompt.getCommand
+                        ? prompt.getCommand(choice.value, this.resolverContext)
+                        : this.buildCommand(prompt.flagName, choice.value);
+                }
+                return promptChoice;
+            });
+        }
+        // Add default value
+        if (defaultValue !== undefined) {
+            config.default = defaultValue;
+        }
+        // Add context if provided
+        if (prompt.context) {
+            config.context = typeof prompt.context === 'function'
+                ? prompt.context(this.resolverContext)
+                : prompt.context;
+        }
+        // For input prompts without choices, add helpful context
+        if (prompt.type === 'input' && !config.context) {
+            config.context = {
+                hint: `Provide ${prompt.flagName} with: ${this.buildCommand(prompt.flagName, '<value>')}`,
+            };
+        }
+        // Output and exit
+        outputPromptAsJson(config, createMetadata(this.options.commandName, this.options.flags));
+        // outputPromptAsJson calls process.exit, but TypeScript doesn't know that
+        // This line is never reached
+        throw new Error('Unreachable');
+    }
+    /**
+     * Prompt for value in interactive mode
+     */
+    async promptInteractive(prompt, message, choices, defaultValue) {
+        // Build inquirer prompt config as a single question object
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const question = {
+            type: prompt.type,
+            name: prompt.flagName,
+            message,
+            default: defaultValue,
+        };
+        // Add choices for list/checkbox
+        if (choices) {
+            question.choices = choices.map(c => ({
+                name: c.name,
+                value: c.value,
+                disabled: c.disabled,
+            }));
+        }
+        // Add validation for input
+        if (prompt.validate) {
+            question.validate = (input) => {
+                return prompt.validate(input, this.resolverContext);
+            };
+        }
+        // Prompt and return value
+        const answers = await inquirer.prompt([question]);
+        return answers[prompt.flagName];
+    }
+    /**
+     * Build a command string for a flag value
+     */
+    buildCommand(flagName, value) {
+        const { baseCommand } = this.options;
+        // Build flags part from currently resolved flags
+        let cmd = baseCommand;
+        // Add any project flag from context
+        const projectId = this.resolverContext.projectId;
+        if (projectId && !this.resolvedFlags['project']) {
+            cmd += ` -P ${projectId}`;
+        }
+        // Add resolved flags (except the one we're prompting for)
+        for (const [key, val] of Object.entries(this.resolvedFlags)) {
+            if (key === flagName || val === undefined || key === 'json')
+                continue;
+            if (typeof val === 'boolean') {
+                if (val)
+                    cmd += ` --${key}`;
+            }
+            else if (typeof val === 'string') {
+                cmd += ` --${key} "${val}"`;
+            }
+            else if (Array.isArray(val)) {
+                cmd += ` --${key} "${val.join(',')}"`;
+            }
+            else {
+                cmd += ` --${key} ${val}`;
+            }
+        }
+        // Add the current flag
+        if (typeof value === 'boolean') {
+            if (value)
+                cmd += ` --${flagName}`;
+        }
+        else if (typeof value === 'string') {
+            cmd += ` --${flagName} "${value}"`;
+        }
+        else if (value !== undefined) {
+            cmd += ` --${flagName} ${value}`;
+        }
+        // Always add --json at the end
+        cmd += ' --json';
+        return cmd;
+    }
+}
+/**
+ * Convenience function to create a FlagResolver from command context
+ */
+export function createFlagResolver(options) {
+    return new FlagResolver(options);
+}
+/**
+ * Helper to check if we should use JSON mode
+ * Re-exported from prompt-json for convenience
+ */
+export { shouldOutputJson, isMachineOutput } from '../prompt-json.js';

package/dist/lib/pmo/base-command.d.ts

@@ -1,11 +1,30 @@
-import { Command } from '@oclif/core';
 import { type PMOContext } from './pmo-context.js';
+import { PromptCommand } from '../prompt-command.js';
 import { type JsonFlags } from '../prompt-json.js';
+/**
+ * Base flags for JSON/agent mode support (legacy)
+ * Include these in your command's flags by spreading: ...jsonModeFlags
+ * @deprecated Use machineOutputFlags instead
+ */
+export declare const jsonModeFlags: {
+    json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
+/**
+ * Base flags for machine-readable output mode
+ * Include these in your command's flags by spreading: ...machineOutputFlags
+ * Supports both --machine (new) and --json (legacy, deprecated)
+ */
+export declare const machineOutputFlags: {
+    machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
 /**
  * Base flags shared by all PMO commands
- * Include these in your command's flags by spreading: ...PMOCommand.baseFlags
+ * Include these in your command's flags by spreading: ...pmoBaseFlags
  */
 export declare const pmoBaseFlags: {
+    machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };
 /**
@@ -43,7 +62,7 @@ export declare const pmoBaseFlags: {
  * }
  * ```
  */
-export declare abstract class PMOCommand extends Command {
+export declare abstract class PMOCommand extends PromptCommand {
     /**
      * PMO context with storage, pmoPath, etc.
      * Available after init() runs (before execute())
@@ -162,6 +181,37 @@ export declare abstract class PMOCommand extends Command {
             example?: string;
         } | null;
     }): Promise<string>;
+    /**
+     * Unified error handler for JSON/interactive modes.
+     *
+     * Consolidates error handling to avoid message drift between JSON and interactive modes.
+     * In JSON mode: outputs structured error JSON and exits
+     * In interactive mode: calls this.error() with the message
+     *
+     * @param code - Error code for JSON output (e.g., 'NOT_FOUND', 'DOCKER_NOT_RUNNING')
+     * @param message - Human-readable error message (used in both modes)
+     * @param options - Configuration for error handling
+     * @returns never - always throws or exits
+     *
+     * @example
+     * ```typescript
+     * // Instead of duplicating messages:
+     * // if (jsonMode) { outputErrorAsJson('CODE', 'msg', ...); }
+     * // this.error('msg');
+     *
+     * // Use:
+     * this.handleError('DOCKER_NOT_RUNNING', 'Docker is not running.', {
+     *   jsonMode,
+     *   commandName: 'agent auth',
+     *   flags,
+     * });
+     * ```
+     */
+    protected handleError(code: string, message: string, options: {
+        jsonMode: boolean;
+        commandName: string;
+        flags: Record<string, unknown>;
+    }): never;
     /**
      * Override run() to delegate to execute() and ensure cleanup
      * Subclasses should implement execute() instead of run()

package/dist/lib/pmo/base-command.js

@@ -1,17 +1,47 @@
-import { Command, Flags } from '@oclif/core';
+import { Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import { getPMOContext } from './pmo-context.js';
 import { styles } from '../styles.js';
-import { shouldOutputJson, outputPromptAsJson, createMetadata, } from '../prompt-json.js';
+import { PromptCommand } from '../prompt-command.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, } from '../prompt-json.js';
+/**
+ * Base flags for JSON/agent mode support (legacy)
+ * Include these in your command's flags by spreading: ...jsonModeFlags
+ * @deprecated Use machineOutputFlags instead
+ */
+export const jsonModeFlags = {
+    json: Flags.boolean({
+        description: 'Output prompts as JSON for AI agents/scripts',
+        default: false,
+    }),
+};
+/**
+ * Base flags for machine-readable output mode
+ * Include these in your command's flags by spreading: ...machineOutputFlags
+ * Supports both --machine (new) and --json (legacy, deprecated)
+ */
+export const machineOutputFlags = {
+    machine: Flags.boolean({
+        char: 'm',
+        description: 'Output as JSON for AI agents/scripts (machine-readable mode)',
+        default: false,
+    }),
+    json: Flags.boolean({
+        description: 'Output as JSON (deprecated, use --machine)',
+        default: false,
+        hidden: true, // Hide from help since it's deprecated
+    }),
+};
 /**
  * Base flags shared by all PMO commands
- * Include these in your command's flags by spreading: ...PMOCommand.baseFlags
+ * Include these in your command's flags by spreading: ...pmoBaseFlags
  */
 export const pmoBaseFlags = {
     project: Flags.string({
         char: 'P',
         description: 'Project ID (uses first project if only one exists)',
     }),
+    ...machineOutputFlags,
 };
 /**
  * Base command class for PMO commands
@@ -48,7 +78,7 @@ export const pmoBaseFlags = {
  * }
  * ```
  */
-export class PMOCommand extends Command {
+export class PMOCommand extends PromptCommand {
     /**
      * PMO context with storage, pmoPath, etc.
      * Available after init() runs (before execute())
@@ -133,19 +163,27 @@ export class PMOCommand extends Command {
             const numB = parseInt(b.name.match(/^(\d+)/)?.[1] || '999', 10);
             return numA - numB;
         });
+        // Auto-detect non-TTY: switch to JSON mode when no TTY present
+        const effectiveJsonMode = options?.jsonMode ?? (!process.stdin.isTTY
+            ? {
+                flags: { json: true },
+                commandName: this.id ?? 'unknown',
+                baseCommand: `prlt ${(this.id ?? 'unknown').replace(/:/g, ' ')}`,
+            }
+            : null);
         // If JSON mode is active, output project choices as JSON
-        if (options?.jsonMode && shouldOutputJson(options.jsonMode.flags)) {
+        if (effectiveJsonMode && shouldOutputJson(effectiveJsonMode.flags)) {
             const choices = sortedProjects.map(p => ({
                 name: `${p.name} (${p.id})`,
                 value: p.id,
-                command: `${options.jsonMode.baseCommand} -P ${p.id} --json`,
+                command: `${effectiveJsonMode.baseCommand} -P ${p.id} --json`,
             }));
             outputPromptAsJson({
                 type: 'list',
                 name: 'project',
                 message: 'Select project:',
                 choices,
-            }, createMetadata(options.jsonMode.commandName, options.jsonMode.flags));
+            }, createMetadata(effectiveJsonMode.commandName, effectiveJsonMode.flags));
             // outputPromptAsJson calls process.exit, so this is unreachable
             return '';
         }
@@ -191,6 +229,10 @@ export class PMOCommand extends Command {
      */
     async selectFromList(options) {
         const { message, items, getName, getValue, getCommand, jsonMode, allowCancel = false, cancelValue, } = options;
+        // Auto-detect non-TTY: switch to JSON mode when no TTY present
+        const effectiveJsonMode = jsonMode ?? (!process.stdin.isTTY
+            ? { flags: { json: true }, commandName: this.id ?? 'unknown' }
+            : null);
         // Build choices with command field
         const choices = items.map(item => ({
             name: getName(item),
@@ -198,13 +240,13 @@ export class PMOCommand extends Command {
             command: getCommand(item),
         }));
         // Check for JSON mode
-        if (jsonMode && shouldOutputJson(jsonMode.flags)) {
+        if (effectiveJsonMode && shouldOutputJson(effectiveJsonMode.flags)) {
             outputPromptAsJson({
                 type: 'list',
                 name: 'selection',
                 message,
                 choices,
-            }, createMetadata(jsonMode.commandName, jsonMode.flags));
+            }, createMetadata(effectiveJsonMode.commandName, effectiveJsonMode.flags));
             // outputPromptAsJson exits, so this is unreachable
             return null;
         }
@@ -238,18 +280,22 @@ export class PMOCommand extends Command {
      */
     async promptForInput(options) {
         const { message, fieldName, defaultValue, validate, jsonMode } = options;
+        // Auto-detect non-TTY: switch to JSON mode when no TTY present
+        const effectiveJsonMode = jsonMode ?? (!process.stdin.isTTY
+            ? { flags: { json: true }, commandName: this.id ?? 'unknown', commandHint: '', example: undefined }
+            : null);
         // Check for JSON mode
-        if (jsonMode && shouldOutputJson(jsonMode.flags)) {
+        if (effectiveJsonMode && shouldOutputJson(effectiveJsonMode.flags)) {
             outputPromptAsJson({
                 type: 'input',
                 name: fieldName,
                 message,
                 default: defaultValue,
                 context: {
-                    hint: jsonMode.commandHint,
-                    example: jsonMode.example,
+                    hint: effectiveJsonMode.commandHint,
+                    example: effectiveJsonMode.example,
                 },
-            }, createMetadata(jsonMode.commandName, jsonMode.flags));
+            }, createMetadata(effectiveJsonMode.commandName, effectiveJsonMode.flags));
             // outputPromptAsJson exits, so this is unreachable
             return '';
         }
@@ -263,6 +309,39 @@ export class PMOCommand extends Command {
             }]);
         return value;
     }
+    /**
+     * Unified error handler for JSON/interactive modes.
+     *
+     * Consolidates error handling to avoid message drift between JSON and interactive modes.
+     * In JSON mode: outputs structured error JSON and exits
+     * In interactive mode: calls this.error() with the message
+     *
+     * @param code - Error code for JSON output (e.g., 'NOT_FOUND', 'DOCKER_NOT_RUNNING')
+     * @param message - Human-readable error message (used in both modes)
+     * @param options - Configuration for error handling
+     * @returns never - always throws or exits
+     *
+     * @example
+     * ```typescript
+     * // Instead of duplicating messages:
+     * // if (jsonMode) { outputErrorAsJson('CODE', 'msg', ...); }
+     * // this.error('msg');
+     *
+     * // Use:
+     * this.handleError('DOCKER_NOT_RUNNING', 'Docker is not running.', {
+     *   jsonMode,
+     *   commandName: 'agent auth',
+     *   flags,
+     * });
+     * ```
+     */
+    handleError(code, message, options) {
+        if (options.jsonMode) {
+            outputErrorAsJson(code, message, createMetadata(options.commandName, options.flags));
+            this.exit(1);
+        }
+        this.error(message);
+    }
     /**
      * Override run() to delegate to execute() and ensure cleanup
      * Subclasses should implement execute() instead of run()

package/dist/lib/pmo/find-pmo.d.ts

@@ -2,7 +2,7 @@
  * Find PMO directory by checking workspace.db for pmo_projects table
  *
  * Search priority:
- * 1. PRLT_HQ_PATH env var (ONLY when DEVCONTAINER=true - for devcontainer mounts)
+ * 1. PRLT_HQ_PATH env var (ONLY when DEVCONTAINER=true or PRLT_TEST_ENV=true)
  * 2. Current directory tree for HQ with PMO
  * 3. Current directory tree for standalone PMO (.pmo/)
  * 4. ~/.proletariat/config.json activeWorkspace (fallback when NOT in any workspace)

package/dist/lib/pmo/find-pmo.js

@@ -52,7 +52,7 @@ function hasPMOTables(dbPath) {
  * Find PMO directory by checking workspace.db for pmo_projects table
  *
  * Search priority:
- * 1. PRLT_HQ_PATH env var (ONLY when DEVCONTAINER=true - for devcontainer mounts)
+ * 1. PRLT_HQ_PATH env var (ONLY when DEVCONTAINER=true or PRLT_TEST_ENV=true)
  * 2. Current directory tree for HQ with PMO
  * 3. Current directory tree for standalone PMO (.pmo/)
  * 4. ~/.proletariat/config.json activeWorkspace (fallback when NOT in any workspace)
@@ -62,10 +62,10 @@ function hasPMOTables(dbPath) {
  * working in different workspaces simultaneously.
  */
 export function findPMO() {
-    // Check PRLT_HQ_PATH environment variable (only in devcontainers)
+    // Check PRLT_HQ_PATH environment variable (only in devcontainers or test environments)
     const hqPath = process.env.PRLT_HQ_PATH;
-    const isDevcontainer = process.env.DEVCONTAINER === 'true';
-    if (hqPath && isDevcontainer) {
+    const allowEnvHqPath = process.env.DEVCONTAINER === 'true' || process.env.PRLT_TEST_ENV === 'true';
+    if (hqPath && allowEnvHqPath) {
         // In devcontainer, PMO is always mounted at /hq/pmo regardless of database value
         // (database stores relative path like "repos/proletariat/pmo" but mount is at /hq/pmo)
         return path.join(hqPath, 'pmo');

package/dist/lib/pmo/index.d.ts

@@ -8,7 +8,7 @@ export { startWatcher, runWatcherForeground, type WatcherOptions, type WatcherIn
 export { createSpecFolders, getSpecFolderPath, getProjectPath, getProductPath, getEpicsPath, } from './create-spec-folders.js';
 export { findPMO } from './find-pmo.js';
 export { getPMOContext, type PMOContext, type GetPMOContextOptions } from './pmo-context.js';
-export { PMOCommand, pmoBaseFlags } from './base-command.js';
+export { PMOCommand, pmoBaseFlags, jsonModeFlags, machineOutputFlags } from './base-command.js';
 export { PMO_TABLES, PMO_TABLE_SCHEMAS, PMO_INDEXES, PMO_SCHEMA_SQL, EXPECTED_TICKET_COLUMNS, validateTicketSchema, } from './schema.js';
 export { BUILTIN_TEMPLATES, getBuiltinTemplate, getPickerTemplates, getColumnsForTemplate, getColumnSettingsForTemplate, } from './templates-builtin.js';
 /**

package/dist/lib/pmo/index.js

@@ -16,7 +16,7 @@ export { startWatcher, runWatcherForeground, } from './watcher.js';
 export { createSpecFolders, getSpecFolderPath, getProjectPath, getProductPath, getEpicsPath, } from './create-spec-folders.js';
 export { findPMO } from './find-pmo.js';
 export { getPMOContext } from './pmo-context.js';
-export { PMOCommand, pmoBaseFlags } from './base-command.js';
+export { PMOCommand, pmoBaseFlags, jsonModeFlags, machineOutputFlags } from './base-command.js';
 export { PMO_TABLES, PMO_TABLE_SCHEMAS, PMO_INDEXES, PMO_SCHEMA_SQL, EXPECTED_TICKET_COLUMNS, validateTicketSchema, } from './schema.js';
 // Re-export template utilities from shared definitions
 export { BUILTIN_TEMPLATES, getBuiltinTemplate, getPickerTemplates, getColumnsForTemplate, getColumnSettingsForTemplate, } from './templates-builtin.js';

package/dist/lib/pmo/storage/helpers.js

@@ -115,7 +115,8 @@ export function rowToSpec(row) {
         status: row.status,
         type: row.type,
         tags: row.tags ? JSON.parse(row.tags) : undefined,
-        dependsOn: row.depends_on ? JSON.parse(row.depends_on) : undefined,
+        // Note: dependsOn is now handled via spec_dependencies table, not inline column
+        dependsOn: undefined,
         problem: row.problem || undefined,
         solution: row.solution || undefined,
         decisions: row.decisions || undefined,

package/dist/lib/pmo/storage/index.d.ts

@@ -3,12 +3,17 @@
  *
  * This is the main facade that delegates to domain-specific storage modules.
  * Uses the unified workspace.db database with pmo_ prefixed tables.
+ *
+ * This module now supports Drizzle ORM for type-safe queries while maintaining
+ * backward compatibility with raw SQL queries during the migration period.
  */
 import Database from 'better-sqlite3';
+import { DrizzleDB } from '../../database/drizzle.js';
 import { AcceptanceCriterion, Board, BoardConfig, BoardView, BoardViewFilter, BoardViewFilters, Column, CreateTicketInput, Epic, EpicDependency, EpicDependencyType, EpicFilter, PhaseFilter, PhaseTemplate, PhaseTemplateFilter, PMOStorage, Project, ProjectFilter, ProjectPhase, Roadmap, RoadmapFilter, RoadmapProject, Spec, SpecDependency, SpecDependencyType, SpecFilter, StateCategory, Subtask, SyncResult, SyncStatus, Ticket, TicketDependency, TicketDependencyType, TicketFilter, TicketTemplate, TicketTemplateFilter, WorkAction, WorkActionFilter, Workflow, WorkflowFilter, WorkflowStatus } from '../types.js';
 export declare class SQLiteStorage implements PMOStorage {
     readonly type: "sqlite";
     private db;
+    private drizzle;
     private dbPath;
     private projectStorage;
     private ticketStorage;
@@ -28,6 +33,10 @@ export declare class SQLiteStorage implements PMOStorage {
      * Get the underlying database connection.
      */
     getDatabase(): Database.Database;
+    /**
+     * Get the Drizzle ORM database connection for type-safe queries.
+     */
+    getDrizzle(): DrizzleDB;
     /**
      * Ensure PMO tables exist in the database.
      */