@auxiora/intent 1.0.0

package/src/decomposer.ts

@@ -0,0 +1,55 @@
+import type { Intent } from './types.js';
+import { IntentParser } from './parser.js';
+
+const COMPOUND_SPLITTERS = [
+  / and then /i,
+  / then /i,
+  / after that /i,
+  / also /i,
+  /,\s*and /,
+  /;\s*/,
+];
+
+export class IntentDecomposer {
+  private parser: IntentParser;
+
+  constructor(parser: IntentParser) {
+    this.parser = parser;
+  }
+
+  decompose(message: string, context?: Record<string, unknown>): Intent[] {
+    const parts = this.splitCompound(message);
+
+    if (parts.length <= 1) {
+      return [this.parser.parse(message, context)];
+    }
+
+    return parts.map((part) => this.parser.parse(part.trim(), context));
+  }
+
+  isCompound(message: string): boolean {
+    return this.splitCompound(message).length > 1;
+  }
+
+  private splitCompound(message: string): string[] {
+    let parts = [message];
+
+    for (const splitter of COMPOUND_SPLITTERS) {
+      const newParts: string[] = [];
+      for (const part of parts) {
+        const split = part.split(splitter);
+        if (split.length > 1) {
+          newParts.push(...split.filter((s) => s.trim().length > 0));
+        } else {
+          newParts.push(part);
+        }
+      }
+      if (newParts.length > parts.length) {
+        parts = newParts;
+        break; // Use first matching splitter only
+      }
+    }
+
+    return parts;
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export type {
+  IntentType,
+  IntentEntity,
+  ActionStep,
+  Intent,
+  IntentParserConfig,
+} from './types.js';
+export { DEFAULT_INTENT_PARSER_CONFIG } from './types.js';
+export { IntentParser } from './parser.js';
+export { ActionPlanner } from './planner.js';
+export { IntentDecomposer } from './decomposer.js';

package/src/parser.ts

@@ -0,0 +1,140 @@
+import type { Intent, IntentType, IntentEntity, IntentParserConfig } from './types.js';
+import { DEFAULT_INTENT_PARSER_CONFIG } from './types.js';
+
+interface KeywordRule {
+  type: IntentType;
+  keywords: string[];
+  weight: number;
+}
+
+const KEYWORD_RULES: KeywordRule[] = [
+  { type: 'send_message', keywords: ['send', 'message', 'tell', 'notify', 'text', 'dm', 'reply'], weight: 1 },
+  { type: 'read_message', keywords: ['read', 'check', 'inbox', 'unread', 'messages'], weight: 1 },
+  { type: 'search', keywords: ['search', 'find', 'look up', 'lookup'], weight: 1 },
+  { type: 'create_file', keywords: ['create', 'new file', 'write file', 'make file', 'generate'], weight: 1 },
+  { type: 'read_file', keywords: ['read file', 'open file', 'show file', 'view'], weight: 1 },
+  { type: 'edit_file', keywords: ['edit', 'modify', 'update file', 'change file'], weight: 1 },
+  { type: 'delete_file', keywords: ['delete', 'remove', 'trash'], weight: 1 },
+  { type: 'browse_web', keywords: ['browse', 'visit', 'open url', 'navigate', 'website', 'go to'], weight: 1 },
+  { type: 'run_command', keywords: ['run', 'command', 'terminal'], weight: 1 },
+  { type: 'schedule', keywords: ['schedule', 'calendar', 'appointment', 'meeting', 'book'], weight: 1 },
+  { type: 'remind', keywords: ['remind', 'reminder', 'alarm', 'alert me'], weight: 1 },
+  { type: 'query', keywords: ['what is', 'who is', 'how to', 'explain', 'tell me about'], weight: 0.8 },
+  { type: 'summarize', keywords: ['summarize', 'summary', 'tldr', 'recap', 'brief'], weight: 1 },
+  { type: 'translate', keywords: ['translate', 'translation', 'in spanish', 'in french', 'in german'], weight: 1 },
+  { type: 'compose', keywords: ['compose', 'draft', 'write an email', 'write a letter', 'write a message'], weight: 1 },
+  { type: 'analyze', keywords: ['analyze', 'analysis', 'review', 'assess'], weight: 0.9 },
+  { type: 'configure', keywords: ['configure', 'settings', 'set up', 'config', 'preferences'], weight: 1 },
+];
+
+const ENTITY_PATTERNS: Array<{ type: string; pattern: RegExp }> = [
+  { type: 'url', pattern: /https?:\/\/[^\s]+/gi },
+  { type: 'email', pattern: /[\w.-]+@[\w.-]+\.\w+/gi },
+  { type: 'file_path', pattern: /(?:\/[\w.-]+)+/g },
+  { type: 'time', pattern: /\b\d{1,2}:\d{2}(?:\s*(?:am|pm))?\b/gi },
+  { type: 'date', pattern: /\b(?:today|tomorrow|yesterday|\d{4}-\d{2}-\d{2})\b/gi },
+  { type: 'mention', pattern: /@[\w.-]+/g },
+];
+
+const CONNECTOR_KEYWORDS: Record<string, string[]> = {
+  slack: ['slack', 'channel'],
+  discord: ['discord', 'server'],
+  email: ['email', 'mail', 'inbox', 'gmail'],
+  calendar: ['calendar', 'schedule', 'meeting', 'appointment'],
+  github: ['github', 'repository', 'repo', 'pull request', 'pr', 'issue'],
+  notion: ['notion', 'page', 'database'],
+};
+
+export class IntentParser {
+  private config: IntentParserConfig;
+
+  constructor(config?: Partial<IntentParserConfig>) {
+    this.config = { ...DEFAULT_INTENT_PARSER_CONFIG, ...config };
+  }
+
+  parse(message: string, context?: Record<string, unknown>): Intent {
+    const lower = message.toLowerCase();
+
+    // Score each intent type
+    const scores = new Map<IntentType, number>();
+
+    for (const rule of KEYWORD_RULES) {
+      let matchCount = 0;
+      for (const keyword of rule.keywords) {
+        if (lower.includes(keyword)) {
+          matchCount++;
+        }
+      }
+      if (matchCount > 0) {
+        // Base score of 0.5 for first match, increasing with more matches
+        const score = Math.min(0.5 + (matchCount - 1) * 0.15, 1) * rule.weight;
+        const current = scores.get(rule.type) ?? 0;
+        scores.set(rule.type, Math.max(current, score));
+      }
+    }
+
+    // Find best match
+    let bestType: IntentType = 'unknown';
+    let bestScore = 0;
+
+    for (const [type, score] of scores) {
+      if (score > bestScore) {
+        bestScore = score;
+        bestType = type;
+      }
+    }
+
+    // Apply confidence threshold
+    const confidence = Math.min(bestScore, 1);
+    if (confidence < this.config.confidenceThreshold) {
+      bestType = 'unknown';
+    }
+
+    // Extract entities
+    const entities = this.extractEntities(message);
+
+    // Detect required connectors
+    const requiredConnectors = this.detectConnectors(lower);
+
+    return {
+      type: bestType,
+      confidence: bestType === 'unknown' ? 0 : confidence,
+      entities,
+      requiredConnectors,
+      actionSteps: [],
+      rawText: message,
+    };
+  }
+
+  private extractEntities(text: string): IntentEntity[] {
+    const entities: IntentEntity[] = [];
+
+    for (const { type, pattern } of ENTITY_PATTERNS) {
+      // Reset regex state for global patterns
+      pattern.lastIndex = 0;
+      let match: RegExpExecArray | null;
+      while ((match = pattern.exec(text)) !== null) {
+        entities.push({
+          type,
+          value: match[0],
+          start: match.index,
+          end: match.index + match[0].length,
+        });
+      }
+    }
+
+    return entities;
+  }
+
+  private detectConnectors(text: string): string[] {
+    const connectors: string[] = [];
+
+    for (const [connector, keywords] of Object.entries(CONNECTOR_KEYWORDS)) {
+      if (keywords.some((kw) => text.includes(kw))) {
+        connectors.push(connector);
+      }
+    }
+
+    return connectors;
+  }
+}

package/src/planner.ts

@@ -0,0 +1,155 @@
+import * as crypto from 'node:crypto';
+import type { Intent, ActionStep } from './types.js';
+
+const INTENT_TO_DOMAIN: Record<string, string> = {
+  send_message: 'messaging',
+  read_message: 'messaging',
+  search: 'web',
+  create_file: 'files',
+  read_file: 'files',
+  edit_file: 'files',
+  delete_file: 'files',
+  browse_web: 'web',
+  run_command: 'shell',
+  schedule: 'calendar',
+  remind: 'calendar',
+  query: 'web',
+  summarize: 'web',
+  translate: 'web',
+  compose: 'messaging',
+  analyze: 'web',
+  configure: 'system',
+};
+
+function makeStep(action: string, domain: string, description: string, params: Record<string, unknown> = {}, dependsOn: string[] = []): ActionStep {
+  return {
+    id: crypto.randomUUID(),
+    action,
+    domain,
+    params,
+    dependsOn,
+    description,
+  };
+}
+
+export class ActionPlanner {
+  planActions(intent: Intent): ActionStep[] {
+    const domain = INTENT_TO_DOMAIN[intent.type] ?? 'system';
+    const steps: ActionStep[] = [];
+
+    switch (intent.type) {
+      case 'send_message': {
+        const recipient = intent.entities.find((e) => e.type === 'mention')?.value;
+        steps.push(makeStep('send_message', domain, `Send message${recipient ? ` to ${recipient}` : ''}`, {
+          recipient,
+          content: intent.rawText,
+        }));
+        break;
+      }
+
+      case 'read_message': {
+        steps.push(makeStep('read_messages', domain, 'Read recent messages'));
+        break;
+      }
+
+      case 'search': {
+        steps.push(makeStep('web_search', domain, 'Search the web', { query: intent.rawText }));
+        break;
+      }
+
+      case 'create_file': {
+        const filePath = intent.entities.find((e) => e.type === 'file_path')?.value;
+        steps.push(makeStep('create_file', domain, `Create file${filePath ? ` at ${filePath}` : ''}`, {
+          path: filePath,
+        }));
+        break;
+      }
+
+      case 'read_file': {
+        const filePath = intent.entities.find((e) => e.type === 'file_path')?.value;
+        steps.push(makeStep('read_file', domain, `Read file${filePath ? ` ${filePath}` : ''}`, {
+          path: filePath,
+        }));
+        break;
+      }
+
+      case 'edit_file': {
+        const filePath = intent.entities.find((e) => e.type === 'file_path')?.value;
+        const readStep = makeStep('read_file', domain, 'Read current file contents', { path: filePath });
+        const editStep = makeStep('edit_file', domain, 'Apply edits to file', { path: filePath }, [readStep.id]);
+        steps.push(readStep, editStep);
+        break;
+      }
+
+      case 'delete_file': {
+        const filePath = intent.entities.find((e) => e.type === 'file_path')?.value;
+        steps.push(makeStep('delete_file', domain, `Delete file${filePath ? ` ${filePath}` : ''}`, {
+          path: filePath,
+        }));
+        break;
+      }
+
+      case 'browse_web': {
+        const url = intent.entities.find((e) => e.type === 'url')?.value;
+        steps.push(makeStep('navigate', domain, `Browse to ${url ?? 'URL'}`, { url }));
+        break;
+      }
+
+      case 'run_command': {
+        steps.push(makeStep('run_command', domain, 'Run shell command', { command: intent.rawText }));
+        break;
+      }
+
+      case 'schedule': {
+        const date = intent.entities.find((e) => e.type === 'date')?.value;
+        const time = intent.entities.find((e) => e.type === 'time')?.value;
+        steps.push(makeStep('create_event', domain, 'Create calendar event', {
+          date,
+          time,
+          description: intent.rawText,
+        }));
+        break;
+      }
+
+      case 'remind': {
+        const date = intent.entities.find((e) => e.type === 'date')?.value;
+        const time = intent.entities.find((e) => e.type === 'time')?.value;
+        steps.push(makeStep('create_reminder', domain, 'Create reminder', {
+          date,
+          time,
+          description: intent.rawText,
+        }));
+        break;
+      }
+
+      case 'compose': {
+        const recipient = intent.entities.find((e) => e.type === 'email' || e.type === 'mention')?.value;
+        steps.push(makeStep('compose', domain, 'Compose message', {
+          recipient,
+          content: intent.rawText,
+        }));
+        break;
+      }
+
+      case 'summarize':
+      case 'translate':
+      case 'analyze':
+      case 'query': {
+        steps.push(makeStep(intent.type, domain, `${intent.type} content`, { input: intent.rawText }));
+        break;
+      }
+
+      case 'configure': {
+        steps.push(makeStep('configure', domain, 'Update configuration', { input: intent.rawText }));
+        break;
+      }
+
+      default: {
+        steps.push(makeStep('unknown', 'system', 'Process request', { input: intent.rawText }));
+        break;
+      }
+    }
+
+    return steps;
+  }
+}

package/src/types.ts

@@ -0,0 +1,53 @@
+export type IntentType =
+  | 'send_message'
+  | 'read_message'
+  | 'search'
+  | 'create_file'
+  | 'read_file'
+  | 'edit_file'
+  | 'delete_file'
+  | 'browse_web'
+  | 'run_command'
+  | 'schedule'
+  | 'remind'
+  | 'query'
+  | 'summarize'
+  | 'translate'
+  | 'compose'
+  | 'analyze'
+  | 'configure'
+  | 'unknown';
+
+export interface IntentEntity {
+  type: string;
+  value: string;
+  start: number;
+  end: number;
+}
+
+export interface ActionStep {
+  id: string;
+  action: string;
+  domain: string;
+  params: Record<string, unknown>;
+  dependsOn: string[];
+  description: string;
+}
+
+export interface Intent {
+  type: IntentType;
+  confidence: number;
+  entities: IntentEntity[];
+  requiredConnectors: string[];
+  actionSteps: ActionStep[];
+  rawText: string;
+}
+
+export interface IntentParserConfig {
+  /** Minimum confidence threshold to accept a classification. */
+  confidenceThreshold: number;
+}
+
+export const DEFAULT_INTENT_PARSER_CONFIG: IntentParserConfig = {
+  confidenceThreshold: 0.3,
+};

package/tests/decomposer.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { IntentParser } from '../src/parser.js';
+import { IntentDecomposer } from '../src/decomposer.js';
+
+describe('IntentDecomposer', () => {
+  const parser = new IntentParser();
+  const decomposer = new IntentDecomposer(parser);
+
+  it('should return single intent for simple message', () => {
+    const intents = decomposer.decompose('Search for TypeScript tutorials');
+    expect(intents).toHaveLength(1);
+    expect(intents[0].type).toBe('search');
+  });
+
+  it('should detect compound intents with "and then"', () => {
+    const intents = decomposer.decompose('Search for the file and then delete it');
+    expect(intents.length).toBeGreaterThan(1);
+  });
+
+  it('should detect compound intents with "then"', () => {
+    const intents = decomposer.decompose('Search for the file then summarize it');
+    expect(intents.length).toBeGreaterThan(1);
+  });
+
+  it('should detect compound intents with semicolons', () => {
+    const intents = decomposer.decompose('Send a message; schedule a meeting');
+    expect(intents).toHaveLength(2);
+  });
+
+  it('should report compound status', () => {
+    expect(decomposer.isCompound('do something')).toBe(false);
+    expect(decomposer.isCompound('do this then do that')).toBe(true);
+  });
+
+  it('should parse each sub-intent independently', () => {
+    const intents = decomposer.decompose('Send a message; search for something');
+    expect(intents.length).toBe(2);
+    // Each should have rawText from its sub-part
+    expect(intents[0].rawText).not.toBe(intents[1].rawText);
+  });
+
+  it('should handle "after that"', () => {
+    const intents = decomposer.decompose('Read the inbox after that send a reply');
+    expect(intents.length).toBeGreaterThan(1);
+  });
+});

package/tests/parser.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import { IntentParser } from '../src/parser.js';
+
+describe('IntentParser', () => {
+  const parser = new IntentParser();
+
+  it('should parse send message intent', () => {
+    const result = parser.parse('Send a message to @john');
+    expect(result.type).toBe('send_message');
+    expect(result.confidence).toBeGreaterThan(0);
+    expect(result.entities.some((e) => e.type === 'mention')).toBe(true);
+  });
+
+  it('should parse search intent', () => {
+    const result = parser.parse('Search for TypeScript tutorials');
+    expect(result.type).toBe('search');
+    expect(result.confidence).toBeGreaterThan(0);
+  });
+
+  it('should parse browse web intent', () => {
+    const result = parser.parse('Navigate to https://example.com');
+    expect(result.type).toBe('browse_web');
+    expect(result.entities.some((e) => e.type === 'url')).toBe(true);
+  });
+
+  it('should parse schedule intent', () => {
+    const result = parser.parse('Schedule a meeting for tomorrow at 3:00 pm');
+    expect(result.type).toBe('schedule');
+    expect(result.entities.some((e) => e.type === 'date')).toBe(true);
+    expect(result.entities.some((e) => e.type === 'time')).toBe(true);
+  });
+
+  it('should parse remind intent', () => {
+    const result = parser.parse('Remind me to call the doctor tomorrow');
+    expect(result.type).toBe('remind');
+    expect(result.confidence).toBeGreaterThan(0);
+  });
+
+  it('should parse delete file intent', () => {
+    const result = parser.parse('Delete the file /tmp/test.txt');
+    expect(result.type).toBe('delete_file');
+    expect(result.entities.some((e) => e.type === 'file_path')).toBe(true);
+  });
+
+  it('should parse run command intent', () => {
+    const result = parser.parse('Run the terminal command to list files');
+    expect(result.type).toBe('run_command');
+  });
+
+  it('should parse summarize intent', () => {
+    const result = parser.parse('Summarize this article for me');
+    expect(result.type).toBe('summarize');
+  });
+
+  it('should return unknown for ambiguous input', () => {
+    const result = parser.parse('hello');
+    expect(result.type).toBe('unknown');
+    expect(result.confidence).toBe(0);
+  });
+
+  it('should detect connectors', () => {
+    const result = parser.parse('Send a message on Slack');
+    expect(result.requiredConnectors).toContain('slack');
+  });
+
+  it('should detect email entities', () => {
+    const result = parser.parse('Send an email to user@example.com');
+    expect(result.entities.some((e) => e.type === 'email')).toBe(true);
+  });
+
+  it('should preserve raw text', () => {
+    const text = 'Schedule a meeting for tomorrow';
+    const result = parser.parse(text);
+    expect(result.rawText).toBe(text);
+  });
+
+  it('should start with empty action steps', () => {
+    const result = parser.parse('Search for something');
+    expect(result.actionSteps).toEqual([]);
+  });
+
+  it('should detect github connector', () => {
+    const result = parser.parse('Create a pull request on github');
+    expect(result.requiredConnectors).toContain('github');
+  });
+
+  it('should parse query intent', () => {
+    const result = parser.parse('What is the capital of France?');
+    expect(result.type).toBe('query');
+  });
+
+  it('should parse translate intent', () => {
+    const result = parser.parse('Translate this to Spanish');
+    expect(result.type).toBe('translate');
+  });
+});

package/tests/planner.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'vitest';
+import { IntentParser } from '../src/parser.js';
+import { ActionPlanner } from '../src/planner.js';
+
+describe('ActionPlanner', () => {
+  const parser = new IntentParser();
+  const planner = new ActionPlanner();
+
+  it('should plan send_message action', () => {
+    const intent = parser.parse('Send a message to @john');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].action).toBe('send_message');
+    expect(steps[0].domain).toBe('messaging');
+  });
+
+  it('should plan edit_file with two steps (read then edit)', () => {
+    const intent = parser.parse('Edit the file /tmp/test.txt');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(2);
+    expect(steps[0].action).toBe('read_file');
+    expect(steps[1].action).toBe('edit_file');
+    expect(steps[1].dependsOn).toContain(steps[0].id);
+  });
+
+  it('should plan browse_web action with URL', () => {
+    const intent = parser.parse('Navigate to https://example.com');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].action).toBe('navigate');
+    expect(steps[0].domain).toBe('web');
+    expect(steps[0].params.url).toBe('https://example.com');
+  });
+
+  it('should plan schedule action', () => {
+    const intent = parser.parse('Schedule a meeting for tomorrow at 3:00 pm');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].action).toBe('create_event');
+    expect(steps[0].domain).toBe('calendar');
+  });
+
+  it('should plan delete_file action', () => {
+    const intent = parser.parse('Delete /tmp/test.txt');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].action).toBe('delete_file');
+    expect(steps[0].params.path).toBe('/tmp/test.txt');
+  });
+
+  it('should plan search action', () => {
+    const intent = parser.parse('Search for TypeScript tutorials');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].action).toBe('web_search');
+    expect(steps[0].domain).toBe('web');
+  });
+
+  it('should plan remind action', () => {
+    const intent = parser.parse('Remind me tomorrow to call the doctor');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].action).toBe('create_reminder');
+    expect(steps[0].domain).toBe('calendar');
+  });
+
+  it('should plan summarize action', () => {
+    const intent = parser.parse('Summarize the article');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].action).toBe('summarize');
+  });
+
+  it('should assign unique IDs to steps', () => {
+    const intent = parser.parse('Edit the file /tmp/test.txt');
+    const steps = planner.planActions(intent);
+    const ids = new Set(steps.map((s) => s.id));
+    expect(ids.size).toBe(steps.length);
+  });
+
+  it('should handle unknown intent', () => {
+    const intent = parser.parse('hello');
+    const steps = planner.planActions(intent);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].action).toBe('unknown');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}