profclaw 0.0.1-beta.1

package/dist/intelligence/ollama.js

@@ -0,0 +1,213 @@
+import { logger } from '../utils/logger.js';
+import { loadConfig } from '../utils/config-loader.js';
+const config = loadConfig('settings.yml');
+/**
+ * Ollama Service for local LLM inference
+ */
+export class OllamaService {
+    baseUrl;
+    summaryModel;
+    embeddingModel;
+    constructor() {
+        this.baseUrl = config.ai?.providers?.ollama?.baseUrl || 'http://localhost:11434';
+        this.summaryModel = config.ai?.providers?.ollama?.summaryModel || 'llama3.2:3b';
+        this.embeddingModel = config.ai?.providers?.ollama?.embeddingModel || 'mxbai-embed-large';
+    }
+    /**
+     * Check if Ollama is available
+     */
+    async healthCheck() {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/tags`, {
+                signal: AbortSignal.timeout(2000),
+            });
+            return response.ok;
+        }
+        catch {
+            logger.debug('[Ollama] Health check failed, service unavailable');
+            return false;
+        }
+    }
+    /**
+     * Generate a structured summary from task output using Ollama
+     */
+    async generateSummary(taskResult, context) {
+        const isAvailable = await this.healthCheck();
+        if (!isAvailable) {
+            logger.warn('[Ollama] Service not available, skipping local summary generation');
+            return null;
+        }
+        const prompt = this.buildSummaryPrompt(taskResult);
+        try {
+            const response = await fetch(`${this.baseUrl}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: this.summaryModel,
+                    prompt,
+                    stream: false,
+                    options: {
+                        temperature: 0.3, // Lower temperature for more focused summaries
+                        num_predict: 1000,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama API error: ${response.status}`);
+            }
+            const data = await response.json();
+            const summaryText = data.response;
+            // Parse the structured output
+            return this.parseStructuredSummary(summaryText, taskResult, context);
+        }
+        catch (error) {
+            logger.error('[Ollama] Summary generation failed:', error);
+            return null;
+        }
+    }
+    /**
+     * Generate an embedding using Ollama
+     */
+    async generateEmbedding(text) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/embeddings`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: this.embeddingModel,
+                    prompt: text.substring(0, 8000),
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama embedding error: ${response.status}`);
+            }
+            const data = await response.json();
+            return data.embedding;
+        }
+        catch (error) {
+            logger.error('[Ollama] Embedding generation failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Build a prompt for summary generation
+     */
+    buildSummaryPrompt(taskResult) {
+        return `You are an AI assistant that creates structured summaries of completed tasks.
+
+TASK OUTPUT:
+${taskResult.output || 'No output provided'}
+
+${taskResult.error ? `ERROR:\n${taskResult.error.message}\n` : ''}
+
+Please analyze this task result and provide a structured summary in the following format:
+
+TITLE: [A concise title describing what was done]
+
+WHAT_CHANGED:
+[Describe the high-level changes made in 2-3 sentences]
+
+WHY_CHANGED:
+[Explain the motivation or reasoning behind these changes in 1-2 sentences]
+
+HOW_CHANGED:
+[Describe the technical approach or implementation strategy]
+
+FILES_CHANGED:
+[List any files that were created, modified, or deleted, one per line in format: action|path]
+
+DECISIONS:
+[List any key technical decisions made, one per line]
+
+Generate the summary now:`;
+    }
+    /**
+     * Parse the LLM output into a CreateSummaryInput
+     */
+    parseStructuredSummary(summaryText, taskResult, context) {
+        const sections = this.extractSections(summaryText);
+        return {
+            taskId: context.taskId,
+            agent: context.agent || 'ollama',
+            model: context.model || this.summaryModel,
+            startedAt: context.startedAt,
+            completedAt: new Date(),
+            title: sections.title || 'AI Task Completed',
+            whatChanged: sections.whatChanged || taskResult.output?.substring(0, 500) || 'Task completed',
+            whyChanged: sections.whyChanged,
+            howChanged: sections.howChanged,
+            filesChanged: this.parseFilesChanged(sections.filesChanged),
+            decisions: this.parseDecisions(sections.decisions),
+            rawOutput: taskResult.output,
+        };
+    }
+    /**
+     * Extract sections from the LLM response
+     */
+    extractSections(text) {
+        const sections = {};
+        const titleMatch = text.match(/TITLE:\s*(.+)/i);
+        if (titleMatch)
+            sections.title = titleMatch[1].trim();
+        const whatMatch = text.match(/WHAT_CHANGED:\s*([\s\S]+?)(?=WHY_CHANGED:|HOW_CHANGED:|FILES_CHANGED:|DECISIONS:|$)/i);
+        if (whatMatch)
+            sections.whatChanged = whatMatch[1].trim();
+        const whyMatch = text.match(/WHY_CHANGED:\s*([\s\S]+?)(?=HOW_CHANGED:|FILES_CHANGED:|DECISIONS:|$)/i);
+        if (whyMatch)
+            sections.whyChanged = whyMatch[1].trim();
+        const howMatch = text.match(/HOW_CHANGED:\s*([\s\S]+?)(?=FILES_CHANGED:|DECISIONS:|$)/i);
+        if (howMatch)
+            sections.howChanged = howMatch[1].trim();
+        const filesMatch = text.match(/FILES_CHANGED:\s*([\s\S]+?)(?=DECISIONS:|$)/i);
+        if (filesMatch)
+            sections.filesChanged = filesMatch[1].trim();
+        const decisionsMatch = text.match(/DECISIONS:\s*([\s\S]+?)$/i);
+        if (decisionsMatch)
+            sections.decisions = decisionsMatch[1].trim();
+        return sections;
+    }
+    /**
+     * Parse files changed from text
+     */
+    parseFilesChanged(text) {
+        if (!text)
+            return [];
+        const files = [];
+        const lines = text.split('\n').filter(l => l.trim());
+        for (const line of lines) {
+            const match = line.match(/(created|modified|deleted|renamed)\|(.+)/i);
+            if (match) {
+                files.push({
+                    action: match[1].toLowerCase(),
+                    path: match[2].trim(),
+                });
+            }
+        }
+        return files;
+    }
+    /**
+     * Parse decisions from text
+     */
+    parseDecisions(text) {
+        if (!text)
+            return [];
+        const decisions = [];
+        const lines = text.split('\n').filter(l => l.trim() && l.trim() !== '-');
+        for (const line of lines) {
+            const cleaned = line.replace(/^[-*]\s*/, '').trim();
+            if (cleaned) {
+                decisions.push({ description: cleaned });
+            }
+        }
+        return decisions;
+    }
+}
+// Singleton instance
+let instance = null;
+export function getOllamaService() {
+    if (!instance) {
+        instance = new OllamaService();
+    }
+    return instance;
+}
+//# sourceMappingURL=ollama.js.map

package/dist/intelligence/rules.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Rules Engine for Pattern-Based Inference
+ *
+ * Zero-cost intelligence layer that handles ~70% of inference needs
+ * without requiring any LLM calls.
+ *
+ * Uses deterministic rules to infer:
+ * - Task type from file paths
+ * - Action type from tool usage
+ * - Issue/PR links from content
+ * - Commit messages from git commands
+ */
+import type { HookInference } from '../hooks/types.js';
+import type { PostToolUsePayload, BashToolInput } from '../hooks/schemas.js';
+/**
+ * Infer task metadata from a PostToolUse hook payload
+ */
+export declare function inferFromToolUse(payload: PostToolUsePayload): HookInference;
+/**
+ * Infer task type and component from file path
+ */
+export declare function inferFromFilePath(filePath: string): Partial<HookInference>;
+/**
+ * Infer action type from tool name
+ */
+export declare function inferActionFromTool(tool: string): string | undefined;
+/**
+ * Infer from Bash command content
+ */
+export declare function inferFromBashCommand(input: BashToolInput): Partial<HookInference>;
+/**
+ * Extract issue and PR links from text content
+ */
+export declare function extractLinks(content: string): Partial<HookInference>;
+/**
+ * Combine multiple hook inferences into a session-level inference
+ */
+export declare function aggregateInferences(inferences: HookInference[]): HookInference;
+//# sourceMappingURL=rules.d.ts.map

package/dist/intelligence/rules.js

@@ -0,0 +1,308 @@
+/**
+ * Rules Engine for Pattern-Based Inference
+ *
+ * Zero-cost intelligence layer that handles ~70% of inference needs
+ * without requiring any LLM calls.
+ *
+ * Uses deterministic rules to infer:
+ * - Task type from file paths
+ * - Action type from tool usage
+ * - Issue/PR links from content
+ * - Commit messages from git commands
+ */
+// File Path Patterns
+// Pre-compiled patterns at module scope for performance
+const PATH_PATTERNS = {
+    auth: /\/(auth|login|logout|session|oauth|jwt|token)\//i,
+    api: /\/(api|routes|endpoints|handlers|controllers)\//i,
+    db: /\/(db|database|models|schema|migrations|drizzle)\//i,
+    test: /\.(test|spec|e2e)\.(ts|tsx|js|jsx)$/i,
+    config: /\/(config|settings|env|\.env)/i,
+    ui: /\/(components|pages|views|screens|ui)\//i,
+    hooks: /\/hooks\//i,
+    utils: /\/(utils|helpers|lib|common)\//i,
+    types: /\/(types|interfaces|schemas)\//i,
+    docs: /\.(md|mdx|rst|txt)$/i,
+    styles: /\.(css|scss|sass|less|styled)\./i,
+};
+const COMPONENT_PATTERNS = {
+    authentication: PATH_PATTERNS.auth,
+    api: PATH_PATTERNS.api,
+    database: PATH_PATTERNS.db,
+    testing: PATH_PATTERNS.test,
+    configuration: PATH_PATTERNS.config,
+    frontend: PATH_PATTERNS.ui,
+    hooks: PATH_PATTERNS.hooks,
+    utilities: PATH_PATTERNS.utils,
+    types: PATH_PATTERNS.types,
+    documentation: PATH_PATTERNS.docs,
+    styling: PATH_PATTERNS.styles,
+};
+// Issue/PR Patterns
+const ISSUE_PATTERN = /#(\d+)/g;
+const PR_PATTERN = /(?:pull\/|pr\/|PR\s*#?)(\d+)/gi;
+const BRANCH_ISSUE_PATTERN = /(?:feat|fix|issue|bug)[/-](\d+)/i;
+// Git command patterns
+const GIT_COMMIT_PATTERN = /git\s+commit\s+(?:-m\s+)?["']([^"']+)["']/i;
+const GIT_PUSH_PATTERN = /git\s+push/i;
+const GIT_BRANCH_PATTERN = /git\s+(?:checkout|switch)\s+(?:-[bB]\s+)?(\S+)/i;
+// Main Inference Functions
+/**
+ * Infer task metadata from a PostToolUse hook payload
+ */
+export function inferFromToolUse(payload) {
+    const inference = {
+        confidence: 0,
+    };
+    // Extract file path if available
+    const filePath = extractFilePath(payload);
+    if (filePath) {
+        const pathInferences = inferFromFilePath(filePath);
+        Object.assign(inference, pathInferences);
+    }
+    // Infer action from tool type
+    const action = inferActionFromTool(payload.tool);
+    if (action) {
+        inference.taskType = inference.taskType || action;
+    }
+    // Check for issue/PR links in content
+    const content = extractContent(payload);
+    if (content) {
+        const links = extractLinks(content);
+        Object.assign(inference, links);
+    }
+    // Handle Bash commands specially
+    if (payload.tool === 'Bash') {
+        const bashInferences = inferFromBashCommand(payload.input);
+        Object.assign(inference, bashInferences);
+    }
+    // Calculate confidence based on how many inferences we made
+    inference.confidence = calculateConfidence(inference);
+    return inference;
+}
+/**
+ * Infer task type and component from file path
+ */
+export function inferFromFilePath(filePath) {
+    const result = {};
+    // Check for task type patterns
+    for (const [component, pattern] of Object.entries(COMPONENT_PATTERNS)) {
+        if (pattern.test(filePath)) {
+            result.component = component;
+            result.taskType = mapComponentToTaskType(component);
+            break;
+        }
+    }
+    // Check for issue number in path
+    const branchMatch = filePath.match(BRANCH_ISSUE_PATTERN);
+    if (branchMatch) {
+        result.linkedIssue = branchMatch[1];
+    }
+    return result;
+}
+/**
+ * Infer action type from tool name
+ */
+export function inferActionFromTool(tool) {
+    const toolActions = {
+        Edit: 'modify',
+        Write: 'create',
+        Read: 'read',
+        Bash: 'execute',
+        Glob: 'search',
+        Grep: 'search',
+        Delete: 'delete',
+        TodoWrite: 'planning',
+        Task: 'orchestration',
+    };
+    return toolActions[tool];
+}
+/**
+ * Infer from Bash command content
+ */
+export function inferFromBashCommand(input) {
+    const result = {};
+    const command = input.command;
+    // Extract commit message
+    const commitMatch = command.match(GIT_COMMIT_PATTERN);
+    if (commitMatch) {
+        result.commitMessage = commitMatch[1];
+        result.taskType = 'commit';
+        // Try to extract issue from commit message (use exec for capture groups with global regex)
+        ISSUE_PATTERN.lastIndex = 0;
+        const issueMatch = ISSUE_PATTERN.exec(commitMatch[1]);
+        if (issueMatch) {
+            result.linkedIssue = issueMatch[1];
+        }
+    }
+    // Check for push (indicates PR might follow)
+    if (GIT_PUSH_PATTERN.test(command)) {
+        result.taskType = 'push';
+    }
+    // Extract branch name
+    const branchMatch = command.match(GIT_BRANCH_PATTERN);
+    if (branchMatch) {
+        const branchName = branchMatch[1];
+        const issueInBranch = branchName.match(BRANCH_ISSUE_PATTERN);
+        if (issueInBranch) {
+            result.linkedIssue = issueInBranch[1];
+        }
+    }
+    // Detect test runs
+    if (/(?:npm|pnpm|yarn)\s+(?:run\s+)?test/i.test(command)) {
+        result.taskType = 'testing';
+    }
+    // Detect build commands
+    if (/(?:npm|pnpm|yarn)\s+(?:run\s+)?build/i.test(command)) {
+        result.taskType = 'build';
+    }
+    // Detect lint commands
+    if (/(?:npm|pnpm|yarn)\s+(?:run\s+)?lint/i.test(command)) {
+        result.taskType = 'lint';
+    }
+    return result;
+}
+/**
+ * Extract issue and PR links from text content
+ */
+export function extractLinks(content) {
+    const result = {};
+    // Find issue references
+    ISSUE_PATTERN.lastIndex = 0;
+    const issueMatch = ISSUE_PATTERN.exec(content);
+    if (issueMatch) {
+        result.linkedIssue = issueMatch[1];
+    }
+    // Find PR references
+    PR_PATTERN.lastIndex = 0;
+    const prMatch = PR_PATTERN.exec(content);
+    if (prMatch) {
+        result.linkedPr = prMatch[1];
+    }
+    return result;
+}
+// Helper Functions
+/**
+ * Extract file path from hook payload input
+ */
+function extractFilePath(payload) {
+    const input = payload.input;
+    return (input.file_path || input.path);
+}
+/**
+ * Extract relevant content from payload for link detection
+ */
+function extractContent(payload) {
+    const parts = [];
+    const input = payload.input;
+    // Add file path
+    if (input.file_path)
+        parts.push(String(input.file_path));
+    // Add old/new strings from Edit
+    if (input.old_string)
+        parts.push(String(input.old_string));
+    if (input.new_string)
+        parts.push(String(input.new_string));
+    // Add content from Write
+    if (input.content)
+        parts.push(String(input.content));
+    // Add command from Bash
+    if (input.command)
+        parts.push(String(input.command));
+    return parts.join(' ');
+}
+/**
+ * Map component type to task type
+ */
+function mapComponentToTaskType(component) {
+    const mapping = {
+        authentication: 'security',
+        api: 'backend',
+        database: 'data',
+        testing: 'quality',
+        configuration: 'config',
+        frontend: 'ui',
+        hooks: 'logic',
+        utilities: 'refactor',
+        types: 'types',
+        documentation: 'docs',
+        styling: 'ui',
+    };
+    return mapping[component] || 'general';
+}
+/**
+ * Calculate confidence score based on inferences
+ */
+function calculateConfidence(inference) {
+    let score = 0;
+    if (inference.taskType)
+        score += 0.3;
+    if (inference.component)
+        score += 0.2;
+    if (inference.linkedIssue)
+        score += 0.25;
+    if (inference.linkedPr)
+        score += 0.15;
+    if (inference.commitMessage)
+        score += 0.1;
+    return Math.min(score, 1);
+}
+// Aggregate Inference
+/**
+ * Combine multiple hook inferences into a session-level inference
+ */
+export function aggregateInferences(inferences) {
+    if (inferences.length === 0) {
+        return { confidence: 0 };
+    }
+    // Find most common task type
+    const taskTypeCounts = new Map();
+    const componentCounts = new Map();
+    let linkedIssue;
+    let linkedPr;
+    let commitMessage;
+    for (const inf of inferences) {
+        if (inf.taskType) {
+            taskTypeCounts.set(inf.taskType, (taskTypeCounts.get(inf.taskType) || 0) + 1);
+        }
+        if (inf.component) {
+            componentCounts.set(inf.component, (componentCounts.get(inf.component) || 0) + 1);
+        }
+        // Take first found issue/PR
+        if (!linkedIssue && inf.linkedIssue)
+            linkedIssue = inf.linkedIssue;
+        if (!linkedPr && inf.linkedPr)
+            linkedPr = inf.linkedPr;
+        // Take last commit message
+        if (inf.commitMessage)
+            commitMessage = inf.commitMessage;
+    }
+    // Get most common values
+    const taskType = getMostCommon(taskTypeCounts);
+    const component = getMostCommon(componentCounts);
+    const result = {
+        taskType,
+        component,
+        linkedIssue,
+        linkedPr,
+        commitMessage,
+        confidence: 0,
+    };
+    result.confidence = calculateConfidence(result);
+    return result;
+}
+/**
+ * Get the most common value from a count map
+ */
+function getMostCommon(counts) {
+    let maxCount = 0;
+    let result;
+    for (const [value, count] of counts) {
+        if (count > maxCount) {
+            maxCount = count;
+            result = value;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=rules.js.map

package/dist/labels/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Labels Service
+ *
+ * Manages labels for tickets with support for:
+ * - Project-scoped labels
+ * - Hierarchical labels (parent/child)
+ * - External sync tracking (GitHub, Linear)
+ */
+export interface Label {
+    id: string;
+    projectId: string | null;
+    name: string;
+    description: string | null;
+    color: string;
+    parentId: string | null;
+    sortOrder: number;
+    externalSource: string | null;
+    externalId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface CreateLabelInput {
+    projectId?: string;
+    name: string;
+    description?: string;
+    color?: string;
+    parentId?: string;
+    externalSource?: string;
+    externalId?: string;
+}
+export interface UpdateLabelInput {
+    name?: string;
+    description?: string;
+    color?: string;
+    parentId?: string | null;
+    sortOrder?: number;
+}
+/**
+ * Create a new label
+ */
+export declare function createLabel(input: CreateLabelInput): Promise<Label>;
+/**
+ * Get a label by ID
+ */
+export declare function getLabel(id: string): Promise<Label | null>;
+/**
+ * List labels for a project (or workspace-level if no projectId)
+ */
+export declare function listLabels(projectId?: string): Promise<Label[]>;
+/**
+ * Update a label
+ */
+export declare function updateLabel(id: string, input: UpdateLabelInput): Promise<Label>;
+/**
+ * Delete a label
+ */
+export declare function deleteLabel(id: string): Promise<void>;
+/**
+ * Add a label to a ticket
+ */
+export declare function addLabelToTicket(ticketId: string, labelId: string): Promise<void>;
+/**
+ * Remove a label from a ticket
+ */
+export declare function removeLabelFromTicket(ticketId: string, labelId: string): Promise<void>;
+/**
+ * Get all labels for a ticket
+ */
+export declare function getTicketLabels(ticketId: string): Promise<Label[]>;
+/**
+ * Set all labels for a ticket (replaces existing)
+ */
+export declare function setTicketLabels(ticketId: string, labelIds: string[]): Promise<void>;
+/**
+ * Find a label by external source and ID
+ */
+export declare function findLabelByExternalId(projectId: string, externalSource: string, externalId: string): Promise<Label | null>;
+/**
+ * Find or create a label from external source
+ */
+export declare function findOrCreateLabel(projectId: string, name: string, options?: {
+    color?: string;
+    externalSource?: string;
+    externalId?: string;
+}): Promise<Label>;
+/**
+ * Sync labels from GitHub issue labels
+ */
+export declare function syncLabelsFromGitHub(projectId: string, githubLabels: Array<{
+    name: string;
+    color?: string;
+}>): Promise<Label[]>;
+//# sourceMappingURL=index.d.ts.map