@fractary/faber-cli 1.0.0 → 1.2.0

package/dist/index.js

@@ -13,6 +13,7 @@ import { createRepoCommand } from './commands/repo/index.js';
 import { createSpecCommand } from './commands/spec/index.js';
 import { createLogsCommand } from './commands/logs/index.js';
 import { createInitCommand } from './commands/init.js';
+import { createPlanCommand } from './commands/plan/index.js';
 const version = '1.0.0';
 /**
  * Create and configure the main CLI program
@@ -25,14 +26,95 @@ export function createFaberCLI() {
         .enablePositionalOptions();
     // Global options
     program.option('--debug', 'Enable debug output');
-    // Workflow commands (top-level)
-    program.addCommand(createInitCommand());
-    program.addCommand(createRunCommand());
-    program.addCommand(createStatusCommand());
-    program.addCommand(createResumeCommand());
-    program.addCommand(createPauseCommand());
-    program.addCommand(createRecoverCommand());
-    program.addCommand(createCleanupCommand());
+    // Workflow commands (top-level) - NEW NAMES
+    program.addCommand(createInitCommand()); // workflow-init
+    program.addCommand(createPlanCommand()); // plan - NEW
+    program.addCommand(createRunCommand()); // workflow-run
+    program.addCommand(createStatusCommand()); // workflow-status
+    program.addCommand(createResumeCommand()); // workflow-resume
+    program.addCommand(createPauseCommand()); // workflow-pause
+    program.addCommand(createRecoverCommand()); // workflow-recover
+    program.addCommand(createCleanupCommand()); // workflow-cleanup
+    // DEPRECATED: Old command names (backwards compatibility)
+    const showDeprecationWarning = (oldName, newName) => {
+        console.warn(chalk.yellow(`\n⚠️  DEPRECATED: "${oldName}" → use "${newName}"\n`));
+    };
+    program
+        .command('init')
+        .description('(DEPRECATED: Use workflow-init)')
+        .option('--preset <name>', 'Use a preset configuration', 'default')
+        .option('--force', 'Overwrite existing configuration')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        showDeprecationWarning('init', 'workflow-init');
+        const initCmd = createInitCommand();
+        initCmd.parse(['', '', ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
+    });
+    program
+        .command('run')
+        .description('(DEPRECATED: Use workflow-run)')
+        .requiredOption('--work-id <id>', 'Work item ID to process')
+        .option('--autonomy <level>', 'Autonomy level', 'supervised')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        showDeprecationWarning('run', 'workflow-run');
+        const runCmd = createRunCommand();
+        runCmd.parse(['', '', '--work-id', options.workId,
+            ...(options.autonomy ? ['--autonomy', options.autonomy] : []),
+            ...(options.json ? ['--json'] : [])
+        ], { from: 'user' });
+    });
+    program
+        .command('status')
+        .description('(DEPRECATED: Use workflow-status)')
+        .option('--work-id <id>', 'Work item ID to check')
+        .option('--workflow-id <id>', 'Workflow ID to check')
+        .option('--verbose', 'Show detailed status')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        showDeprecationWarning('status', 'workflow-status');
+        const statusCmd = createStatusCommand();
+        statusCmd.parse(['', '', ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
+    });
+    program
+        .command('resume <workflow_id>')
+        .description('(DEPRECATED: Use workflow-resume)')
+        .option('--json', 'Output as JSON')
+        .action((workflowId, options) => {
+        showDeprecationWarning('resume', 'workflow-resume');
+        const resumeCmd = createResumeCommand();
+        resumeCmd.parse(['', '', workflowId, ...(options.json ? ['--json'] : [])], { from: 'user' });
+    });
+    program
+        .command('pause <workflow_id>')
+        .description('(DEPRECATED: Use workflow-pause)')
+        .option('--json', 'Output as JSON')
+        .action((workflowId, options) => {
+        showDeprecationWarning('pause', 'workflow-pause');
+        const pauseCmd = createPauseCommand();
+        pauseCmd.parse(['', '', workflowId, ...(options.json ? ['--json'] : [])], { from: 'user' });
+    });
+    program
+        .command('recover <workflow_id>')
+        .description('(DEPRECATED: Use workflow-recover)')
+        .option('--checkpoint <id>', 'Specific checkpoint ID')
+        .option('--phase <phase>', 'Recover to specific phase')
+        .option('--json', 'Output as JSON')
+        .action((workflowId, options) => {
+        showDeprecationWarning('recover', 'workflow-recover');
+        const recoverCmd = createRecoverCommand();
+        recoverCmd.parse(['', '', workflowId, ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
+    });
+    program
+        .command('cleanup')
+        .description('(DEPRECATED: Use workflow-cleanup)')
+        .option('--max-age <days>', 'Delete workflows older than N days', '30')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        showDeprecationWarning('cleanup', 'workflow-cleanup');
+        const cleanupCmd = createCleanupCommand();
+        cleanupCmd.parse(['', '', ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
+    });
     // Subcommand trees
     program.addCommand(createWorkCommand());
     program.addCommand(createRepoCommand());

package/dist/lib/anthropic-client.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Anthropic API Client
+ *
+ * Generates workflow plans via Claude API
+ */
+import type { FaberConfig } from '../types/config.js';
+interface GeneratePlanInput {
+    workflow: string;
+    issueTitle: string;
+    issueDescription: string;
+    issueNumber: number;
+}
+interface WorkflowPlan {
+    plan_id: string;
+    created_by: string;
+    cli_version: string;
+    created_at: string;
+    issue: {
+        source: string;
+        id: string;
+        url: string;
+    };
+    branch: string;
+    worktree: string;
+    workflow: string;
+    phases: any[];
+    [key: string]: any;
+}
+/**
+ * Anthropic API Client
+ */
+export declare class AnthropicClient {
+    private client;
+    private config;
+    private git;
+    private ajv;
+    private planSchema;
+    constructor(config: FaberConfig);
+    /**
+     * Load plan JSON schema for validation
+     */
+    private loadPlanSchema;
+    /**
+     * Validate plan JSON against schema
+     */
+    private validatePlan;
+    /**
+     * Generate workflow plan via Claude API
+     */
+    generatePlan(input: GeneratePlanInput): Promise<WorkflowPlan>;
+    /**
+     * Load workflow configuration
+     */
+    private loadWorkflowConfig;
+    /**
+     * Construct planning prompt for Claude
+     */
+    private constructPlanningPrompt;
+    /**
+     * Extract JSON from Claude response
+     */
+    private extractJsonFromResponse;
+    /**
+     * Extract repository organization and project name using SDK Git class
+     */
+    private extractRepoInfo;
+}
+export {};
+//# sourceMappingURL=anthropic-client.d.ts.map

package/dist/lib/anthropic-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-client.d.ts","sourceRoot":"","sources":["../../src/lib/anthropic-client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKtD,UAAU,iBAAiB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,EAAE,EAAE,MAAM,CAAC;QACX,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,UAAU,CAAM;gBAEZ,MAAM,EAAE,WAAW;IAe/B;;OAEG;YACW,cAAc;IAiB5B;;OAEG;IACH,OAAO,CAAC,YAAY;IAepB;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC;IA6DnE;;OAEG;YACW,kBAAkB;IAchC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAqD/B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;OAEG;YACW,eAAe;CAqB9B"}

package/dist/lib/anthropic-client.js

@@ -0,0 +1,225 @@
+/**
+ * Anthropic API Client
+ *
+ * Generates workflow plans via Claude API
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import Ajv from 'ajv';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Git } from '@fractary/faber';
+import { validateJsonSize } from '../utils/validation.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Anthropic API Client
+ */
+export class AnthropicClient {
+    constructor(config) {
+        this.config = config;
+        this.git = new Git();
+        this.ajv = new Ajv({ strict: false }); // Allow additional properties
+        const apiKey = config.anthropic?.api_key;
+        if (!apiKey) {
+            throw new Error('Anthropic API key not found. Set ANTHROPIC_API_KEY environment variable.');
+        }
+        this.client = new Anthropic({
+            apiKey,
+        });
+    }
+    /**
+     * Load plan JSON schema for validation
+     */
+    async loadPlanSchema() {
+        if (this.planSchema) {
+            return; // Already loaded
+        }
+        try {
+            // Schema path relative to this file
+            const schemaPath = path.resolve(__dirname, '../../../plugins/faber/config/schemas/plan.schema.json');
+            const schemaContent = await fs.readFile(schemaPath, 'utf8');
+            this.planSchema = JSON.parse(schemaContent);
+        }
+        catch (error) {
+            // Schema not found or invalid - log warning but don't fail
+            console.warn('Warning: Could not load plan schema for validation:', error instanceof Error ? error.message : 'Unknown error');
+            this.planSchema = null;
+        }
+    }
+    /**
+     * Validate plan JSON against schema
+     */
+    validatePlan(plan) {
+        if (!this.planSchema) {
+            // Schema not loaded - skip validation
+            return;
+        }
+        const validate = this.ajv.compile(this.planSchema);
+        const valid = validate(plan);
+        if (!valid) {
+            const errors = validate.errors?.map(e => `${e.instancePath} ${e.message}`).join(', ') || 'Unknown validation errors';
+            throw new Error(`Plan JSON validation failed: ${errors}`);
+        }
+    }
+    /**
+     * Generate workflow plan via Claude API
+     */
+    async generatePlan(input) {
+        // Load plan schema for validation
+        await this.loadPlanSchema();
+        // Load workflow configuration
+        const workflowConfig = await this.loadWorkflowConfig(input.workflow);
+        // Generate plan ID
+        const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z/, '').replace('T', '-');
+        const planId = `fractary-faber-${input.issueNumber}-${timestamp}`;
+        // Construct prompt for Claude
+        const prompt = this.constructPlanningPrompt(input, workflowConfig);
+        // Call Claude API
+        const response = await this.client.messages.create({
+            model: 'claude-sonnet-4-5-20250929',
+            max_tokens: 8192,
+            messages: [
+                {
+                    role: 'user',
+                    content: prompt,
+                },
+            ],
+        });
+        // Extract plan JSON from response
+        const content = response.content[0];
+        if (content.type !== 'text') {
+            throw new Error('Unexpected response type from Claude API');
+        }
+        // Validate response size (prevent DoS)
+        validateJsonSize(content.text, 1024 * 1024); // 1MB limit
+        const planJson = this.extractJsonFromResponse(content.text);
+        // Add metadata
+        const { organization, project } = await this.extractRepoInfo();
+        const plan = {
+            ...planJson,
+            plan_id: planId,
+            created_by: 'cli',
+            cli_version: '1.0.0',
+            created_at: new Date().toISOString(),
+            issue: {
+                source: 'github',
+                id: input.issueNumber.toString(),
+                url: `https://github.com/${organization}/${project}/issues/${input.issueNumber}`,
+            },
+            branch: `feature/${input.issueNumber}`,
+            worktree: `~/.claude-worktrees/${organization}-${project}-${input.issueNumber}`,
+            workflow: input.workflow,
+        };
+        // Validate plan against schema
+        this.validatePlan(plan);
+        return plan;
+    }
+    /**
+     * Load workflow configuration
+     */
+    async loadWorkflowConfig(workflow) {
+        const workflowPath = path.join(this.config.workflow?.config_path || './plugins/faber/config/workflows', `${workflow}.json`);
+        try {
+            const content = await fs.readFile(workflowPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to load workflow config: ${workflow} (${workflowPath})`);
+        }
+    }
+    /**
+     * Construct planning prompt for Claude
+     */
+    constructPlanningPrompt(input, workflowConfig) {
+        return `You are a workflow planning assistant for the FABER system. Your task is to generate a structured workflow plan based on the provided issue and workflow configuration.
+
+**Issue Information:**
+- Number: #${input.issueNumber}
+- Title: ${input.issueTitle}
+- Description: ${input.issueDescription}
+
+**Workflow Type:** ${input.workflow}
+
+**Workflow Configuration:**
+${JSON.stringify(workflowConfig, null, 2)}
+
+**Your Task:**
+Generate a complete workflow plan that includes:
+1. All phases from the workflow configuration
+2. Specific steps for each phase based on the issue requirements
+3. Success criteria for each phase
+4. Estimated complexity
+
+**Output Format:**
+Return ONLY a valid JSON object with the following structure:
+
+\`\`\`json
+{
+  "phases": [
+    {
+      "phase": "phase_name",
+      "description": "What this phase accomplishes",
+      "steps": [
+        {
+          "action": "specific action to take",
+          "details": "additional context or requirements"
+        }
+      ],
+      "success_criteria": [
+        "criterion 1",
+        "criterion 2"
+      ],
+      "complexity": "low|medium|high"
+    }
+  ],
+  "overall_complexity": "low|medium|high",
+  "estimated_phases": 4,
+  "special_considerations": [
+    "Any special notes or warnings"
+  ]
+}
+\`\`\`
+
+Generate the plan now:`;
+    }
+    /**
+     * Extract JSON from Claude response
+     */
+    extractJsonFromResponse(text) {
+        // Try to find JSON in code blocks
+        const jsonBlockMatch = text.match(/```json\s*\n([\s\S]*?)\n```/);
+        if (jsonBlockMatch) {
+            return JSON.parse(jsonBlockMatch[1]);
+        }
+        // Try to find JSON in the text
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            return JSON.parse(jsonMatch[0]);
+        }
+        throw new Error('Could not extract JSON from Claude response');
+    }
+    /**
+     * Extract repository organization and project name using SDK Git class
+     */
+    async extractRepoInfo() {
+        try {
+            const remoteUrl = this.git.exec('remote get-url origin');
+            // Parse git@github.com:organization/project.git or https://github.com/organization/project.git
+            const match = remoteUrl.match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?$/);
+            if (match) {
+                return {
+                    organization: match[1],
+                    project: match[2],
+                };
+            }
+        }
+        catch (error) {
+            // Fall back to config or defaults
+        }
+        return {
+            organization: this.config.github?.organization || 'unknown',
+            project: this.config.github?.project || 'unknown',
+        };
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Configuration Manager
+ *
+ * Loads FABER CLI configuration and respects Claude Code settings
+ */
+import type { FaberConfig } from '../types/config.js';
+/**
+ * Configuration Manager
+ */
+export declare class ConfigManager {
+    private config;
+    private constructor();
+    /**
+     * Load configuration
+     */
+    static load(): Promise<FaberConfig>;
+    /**
+     * Read Claude Code configuration for worktree location
+     */
+    private static readClaudeCodeWorktreeLocation;
+    /**
+     * Get Claude Code configuration paths by platform
+     */
+    private static getClaudeConfigPaths;
+    /**
+     * Get configuration value
+     */
+    get(key: keyof FaberConfig): any;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/lib/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,oBAAoB,CAAC;AAEpE;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO;IAIP;;OAEG;WACU,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC;IAgEzC;;OAEG;mBACkB,8BAA8B;IAoBnD;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAyBnC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,WAAW,GAAG,GAAG;CAGjC"}

package/dist/lib/config.js

@@ -0,0 +1,127 @@
+/**
+ * Configuration Manager
+ *
+ * Loads FABER CLI configuration and respects Claude Code settings
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+/**
+ * Configuration Manager
+ */
+export class ConfigManager {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Load configuration
+     */
+    static async load() {
+        const config = {};
+        // Load from environment variables
+        config.anthropic = {
+            api_key: process.env.ANTHROPIC_API_KEY,
+        };
+        config.github = {
+            token: process.env.GITHUB_TOKEN,
+        };
+        // Load from FABER config file
+        try {
+            const faberConfigPath = path.join(process.cwd(), '.fractary', 'settings.json');
+            const faberConfigContent = await fs.readFile(faberConfigPath, 'utf-8');
+            const faberConfig = JSON.parse(faberConfigContent);
+            // Merge with config
+            if (faberConfig.anthropic) {
+                config.anthropic = { ...config.anthropic, ...faberConfig.anthropic };
+            }
+            if (faberConfig.github) {
+                config.github = { ...config.github, ...faberConfig.github };
+            }
+            if (faberConfig.worktree) {
+                config.worktree = { ...config.worktree, ...faberConfig.worktree };
+            }
+            if (faberConfig.workflow) {
+                config.workflow = { ...config.workflow, ...faberConfig.workflow };
+            }
+        }
+        catch (error) {
+            // FABER config not found, use defaults
+        }
+        // Read Claude Code configuration for worktree location
+        if (!config.worktree?.location || config.worktree?.inherit_from_claude !== false) {
+            const claudeWorktreeLocation = await ConfigManager.readClaudeCodeWorktreeLocation();
+            if (claudeWorktreeLocation) {
+                if (!config.worktree) {
+                    config.worktree = {};
+                }
+                config.worktree.location = claudeWorktreeLocation;
+            }
+        }
+        // Set defaults
+        if (!config.worktree?.location) {
+            config.worktree = {
+                ...config.worktree,
+                location: path.join(os.homedir(), '.claude-worktrees'),
+            };
+        }
+        if (!config.workflow?.config_path) {
+            config.workflow = {
+                ...config.workflow,
+                config_path: path.join(process.cwd(), 'plugins', 'faber', 'config', 'workflows'),
+            };
+        }
+        return config;
+    }
+    /**
+     * Read Claude Code configuration for worktree location
+     */
+    static async readClaudeCodeWorktreeLocation() {
+        const configPaths = ConfigManager.getClaudeConfigPaths();
+        for (const configPath of configPaths) {
+            try {
+                const content = await fs.readFile(configPath, 'utf-8');
+                const config = JSON.parse(content);
+                if (config.worktree?.directory) {
+                    return config.worktree.directory;
+                }
+            }
+            catch (error) {
+                // Config file not found or not readable, try next
+                continue;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get Claude Code configuration paths by platform
+     */
+    static getClaudeConfigPaths() {
+        const homeDir = os.homedir();
+        const platform = os.platform();
+        switch (platform) {
+            case 'linux':
+                return [
+                    path.join(homeDir, '.config', 'claude', 'config.json'),
+                    path.join(homeDir, '.claude', 'config.json'),
+                ];
+            case 'darwin': // macOS
+                return [
+                    path.join(homeDir, 'Library', 'Application Support', 'Claude', 'config.json'),
+                    path.join(homeDir, '.config', 'claude', 'config.json'),
+                ];
+            case 'win32': // Windows
+                return [
+                    path.join(process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming'), 'Claude', 'config.json'),
+                    path.join(homeDir, '.claude', 'config.json'),
+                ];
+            default:
+                return [path.join(homeDir, '.claude', 'config.json')];
+        }
+    }
+    /**
+     * Get configuration value
+     */
+    get(key) {
+        return this.config[key];
+    }
+}

package/dist/lib/repo-client.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Repo Client
+ *
+ * Wrapper for fractary-repo plugin commands (CLI-based)
+ */
+interface Issue {
+    id: string;
+    number: number;
+    title: string;
+    description: string;
+    labels: string[];
+    url: string;
+    state: string;
+}
+interface WorktreeResult {
+    path: string;
+    absolute_path: string;
+    branch: string;
+    created_at: string;
+    organization: string;
+    project: string;
+    work_id: string;
+}
+interface IssueUpdateOptions {
+    id: string;
+    comment?: string;
+    addLabel?: string;
+    removeLabel?: string;
+}
+/**
+ * Repo Client - wraps fractary-repo plugin CLI operations
+ *
+ * Note: This calls fractary-repo CLI commands as specified in SPEC-00030.
+ * These commands must be implemented in the fractary-repo plugin.
+ */
+export declare class RepoClient {
+    private config;
+    constructor(config: any);
+    /**
+     * Fetch specific issues by ID
+     *
+     * Calls: fractary-repo issue-fetch --ids 258,259,260 --format json
+     */
+    fetchIssues(ids: string[]): Promise<Issue[]>;
+    /**
+     * Search issues by labels
+     *
+     * Calls: fractary-repo issue-search --labels "workflow:etl,status:approved" --format json
+     */
+    searchIssues(labels: string[]): Promise<Issue[]>;
+    /**
+     * Create a git branch
+     *
+     * Calls: fractary-repo branch-create <branch-name> --format json
+     */
+    createBranch(branchName: string): Promise<void>;
+    /**
+     * Create a git worktree
+     *
+     * Calls: fractary-repo worktree-create --work-id 258 --format json
+     */
+    createWorktree(options: {
+        workId: string;
+        path?: string;
+    }): Promise<WorktreeResult>;
+    /**
+     * Update GitHub issue
+     *
+     * Calls: fractary-repo issue-update --id 258 --comment "..." --add-label "..."
+     */
+    updateIssue(options: IssueUpdateOptions): Promise<void>;
+    /**
+     * Call fractary-repo CLI command
+     *
+     * This will be implemented to spawn fractary-repo CLI process safely.
+     * For now, this is a placeholder showing the intended interface.
+     */
+    private callRepoCommand;
+}
+export {};
+//# sourceMappingURL=repo-client.d.ts.map

package/dist/lib/repo-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-client.d.ts","sourceRoot":"","sources":["../../src/lib/repo-client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,UAAU,KAAK;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,kBAAkB;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAM;gBAER,MAAM,EAAE,GAAG;IASvB;;;;OAIG;IACG,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAQlD;;;;OAIG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAQtD;;;;OAIG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQrD;;;;OAIG;IACG,cAAc,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAazF;;;;OAIG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB7D;;;;;OAKG;YACW,eAAe;CAU9B"}