@auxiora/compose 1.0.0

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,GAAG,QAAQ,GAAG,cAAc,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAC7F,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEzF,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,cAAc,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@auxiora/compose",
+  "version": "1.0.0",
+  "description": "Context-aware writing assistant with tone adaptation, templates, and grammar checking",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "nanoid": "^5.1.2",
+    "@auxiora/logger": "1.0.0",
+    "@auxiora/audit": "1.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/composer.ts

@@ -0,0 +1,72 @@
+import type { Tone, Platform, ComposeRequest, ComposeResult, ComposeContext } from './types.js';
+
+export class ComposeEngine {
+  private defaultTone: Tone;
+
+  constructor(config?: { defaultTone?: Tone }) {
+    this.defaultTone = config?.defaultTone ?? 'professional';
+  }
+
+  compose(request: ComposeRequest): ComposeResult {
+    const tone = request.context.tone ?? this.adaptToneForPlatform(request.context.platform);
+    let text = request.content ?? request.instruction ?? '';
+
+    text = this.enforceConstraints(text, request.context);
+    text = this.addSignOff(text, tone, request.context.platform);
+
+    return {
+      text,
+      tone,
+      platform: request.context.platform,
+      wordCount: this.countWords(text),
+      characterCount: text.length,
+    };
+  }
+
+  private adaptToneForPlatform(platform: Platform): Tone {
+    const map: Record<Platform, Tone> = {
+      email: 'formal',
+      slack: 'casual',
+      linkedin: 'professional',
+      twitter: 'brief',
+      reddit: 'casual',
+      generic: 'professional',
+    };
+    return map[platform];
+  }
+
+  private enforceConstraints(text: string, context: ComposeContext): string {
+    if (context.platform === 'twitter' && text.length > 280) {
+      text = text.slice(0, 277) + '...';
+    }
+
+    if (context.maxLength && text.length > context.maxLength) {
+      text = text.slice(0, context.maxLength - 3) + '...';
+    }
+
+    return text;
+  }
+
+  private addSignOff(text: string, tone: Tone, platform: Platform): string {
+    if (platform !== 'email' && platform !== 'linkedin') {
+      return text;
+    }
+
+    const signOffs: Record<Tone, string> = {
+      formal: '\n\nBest regards,',
+      professional: '\n\nBest,',
+      casual: '\n\nThanks!',
+      brief: '',
+      friendly: '\n\nCheers!',
+      assertive: '\n\nRegards,',
+    };
+
+    return text + signOffs[tone];
+  }
+
+  private countWords(text: string): number {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) return 0;
+    return trimmed.split(/\s+/).length;
+  }
+}

package/src/grammar.ts

@@ -0,0 +1,139 @@
+import type { GrammarIssue } from './types.js';
+
+export class GrammarChecker {
+  check(text: string): GrammarIssue[] {
+    const issues: GrammarIssue[] = [
+      ...this.checkDoubleSpaces(text),
+      ...this.checkRepeatedWords(text),
+      ...this.checkLongSentences(text),
+      ...this.checkPassiveVoice(text),
+      ...this.checkWeaselWords(text),
+      ...this.checkMissingPeriod(text),
+    ];
+
+    issues.sort((a, b) => a.position.start - b.position.start);
+    return issues;
+  }
+
+  private checkDoubleSpaces(text: string): GrammarIssue[] {
+    const issues: GrammarIssue[] = [];
+    const pattern = /  /g;
+    let match: RegExpExecArray | null;
+
+    while ((match = pattern.exec(text)) !== null) {
+      issues.push({
+        type: 'style',
+        message: 'Double space detected',
+        position: { start: match.index, end: match.index + 2 },
+        suggestion: ' ',
+        severity: 'warning',
+      });
+    }
+
+    return issues;
+  }
+
+  private checkRepeatedWords(text: string): GrammarIssue[] {
+    const issues: GrammarIssue[] = [];
+    const pattern = /\b(\w+)\s+\1\b/gi;
+    let match: RegExpExecArray | null;
+
+    while ((match = pattern.exec(text)) !== null) {
+      issues.push({
+        type: 'grammar',
+        message: `Repeated word: "${match[1]}"`,
+        position: { start: match.index, end: match.index + match[0].length },
+        suggestion: match[1],
+        severity: 'error',
+      });
+    }
+
+    return issues;
+  }
+
+  private checkLongSentences(text: string): GrammarIssue[] {
+    const issues: GrammarIssue[] = [];
+    const sentences = text.split(/[.!?]+/);
+    let offset = 0;
+
+    for (const sentence of sentences) {
+      const trimmed = sentence.trim();
+      const wordCount = trimmed.length > 0 ? trimmed.split(/\s+/).length : 0;
+
+      if (wordCount > 40) {
+        const start = text.indexOf(trimmed, offset);
+        issues.push({
+          type: 'style',
+          message: `Sentence is ${wordCount} words long (recommended: under 40)`,
+          position: { start, end: start + trimmed.length },
+          severity: 'warning',
+        });
+      }
+
+      offset += sentence.length + 1;
+    }
+
+    return issues;
+  }
+
+  private checkPassiveVoice(text: string): GrammarIssue[] {
+    const issues: GrammarIssue[] = [];
+    const pattern = /\b(was|were|been|being)\s+\w+ed\b/gi;
+    let match: RegExpExecArray | null;
+
+    while ((match = pattern.exec(text)) !== null) {
+      issues.push({
+        type: 'clarity',
+        message: 'Possible passive voice',
+        position: { start: match.index, end: match.index + match[0].length },
+        severity: 'info',
+      });
+    }
+
+    return issues;
+  }
+
+  private checkWeaselWords(text: string): GrammarIssue[] {
+    const issues: GrammarIssue[] = [];
+    const weaselWords = [
+      'very', 'really', 'quite', 'somewhat', 'fairly',
+      'rather', 'basically', 'essentially', 'generally',
+    ];
+
+    for (const word of weaselWords) {
+      const pattern = new RegExp(`\\b${word}\\b`, 'gi');
+      let match: RegExpExecArray | null;
+
+      while ((match = pattern.exec(text)) !== null) {
+        issues.push({
+          type: 'style',
+          message: `Weasel word: "${match[0]}"`,
+          position: { start: match.index, end: match.index + match[0].length },
+          severity: 'warning',
+        });
+      }
+    }
+
+    return issues;
+  }
+
+  private checkMissingPeriod(text: string): GrammarIssue[] {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) return [];
+
+    const lastChar = trimmed[trimmed.length - 1];
+    if (!['.', '!', '?', ':', ';'].includes(lastChar)) {
+      return [
+        {
+          type: 'grammar',
+          message: 'Text does not end with punctuation',
+          position: { start: trimmed.length - 1, end: trimmed.length },
+          suggestion: trimmed + '.',
+          severity: 'warning',
+        },
+      ];
+    }
+
+    return [];
+  }
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+export { ComposeEngine } from './composer.js';
+export { TemplateEngine } from './templates.js';
+export { GrammarChecker } from './grammar.js';
+export { LanguageDetector } from './language.js';
+export type {
+  Tone,
+  Platform,
+  ComposeRequest,
+  ComposeContext,
+  ComposeResult,
+  Template,
+  GrammarIssue,
+  LanguageResult,
+} from './types.js';

package/src/language.ts

@@ -0,0 +1,47 @@
+import type { LanguageResult } from './types.js';
+
+const LANGUAGE_INDICATORS: Record<string, string[]> = {
+  english: ['the', 'is', 'are', 'was', 'have', 'been', 'that', 'this', 'with', 'from'],
+  spanish: ['el', 'la', 'los', 'las', 'de', 'en', 'que', 'un', 'una', 'por', 'con', 'es'],
+  french: ['le', 'la', 'les', 'des', 'un', 'une', 'de', 'en', 'est', 'que', 'dans', 'avec'],
+  german: ['der', 'die', 'das', 'und', 'ist', 'ein', 'eine', 'mit', 'auf', 'für', 'von'],
+  portuguese: ['o', 'a', 'os', 'as', 'de', 'em', 'que', 'um', 'uma', 'com', 'por'],
+};
+
+const RTL_LANGUAGES = new Set(['arabic', 'hebrew', 'persian', 'urdu']);
+
+export class LanguageDetector {
+  detect(text: string): LanguageResult {
+    const words = text.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
+    if (words.length === 0) {
+      return { language: 'unknown', confidence: 0 };
+    }
+
+    let bestLanguage = 'unknown';
+    let bestCount = 0;
+
+    for (const [language, indicators] of Object.entries(LANGUAGE_INDICATORS)) {
+      let count = 0;
+      for (const word of words) {
+        if (indicators.includes(word)) {
+          count++;
+        }
+      }
+      if (count > bestCount) {
+        bestCount = count;
+        bestLanguage = language;
+      }
+    }
+
+    const confidence = bestCount / words.length;
+
+    return {
+      language: bestLanguage,
+      confidence: Math.round(confidence * 100) / 100,
+    };
+  }
+
+  isRTL(language: string): boolean {
+    return RTL_LANGUAGES.has(language.toLowerCase());
+  }
+}

package/src/templates.ts

@@ -0,0 +1,97 @@
+import type { Template, Tone } from './types.js';
+
+const BUILT_IN: readonly Omit<Template, 'id'>[] = [
+  {
+    name: 'Meeting Follow-Up',
+    category: 'business',
+    body: 'Hi {{name}},\n\nThank you for taking the time to meet today. Here\'s a summary of what we discussed:\n\n{{summary}}\n\nNext steps:\n{{nextSteps}}\n\nPlease let me know if I missed anything.',
+    variables: ['name', 'summary', 'nextSteps'],
+    tone: 'formal' as Tone,
+  },
+  {
+    name: 'Introduction',
+    category: 'networking',
+    body: 'Hi {{name}},\n\nI\'m {{senderName}} from {{company}}. {{reason}}\n\nI\'d love to connect and discuss further.',
+    variables: ['name', 'senderName', 'company', 'reason'],
+    tone: 'professional' as Tone,
+  },
+  {
+    name: 'Thank You',
+    category: 'personal',
+    body: 'Hi {{name}},\n\nThank you so much for {{reason}}. I really appreciate it.\n\n{{additionalNote}}',
+    variables: ['name', 'reason', 'additionalNote'],
+    tone: 'friendly' as Tone,
+  },
+  {
+    name: 'Cold Outreach',
+    category: 'sales',
+    body: 'Hi {{name}},\n\n{{hook}}\n\n{{valueProposition}}\n\nWould you be open to a {{meetingLength}} minute chat this week?',
+    variables: ['name', 'hook', 'valueProposition', 'meetingLength'],
+    tone: 'professional' as Tone,
+  },
+  {
+    name: 'Status Update',
+    category: 'business',
+    body: '{{greeting}}\n\nHere\'s the status update for {{project}}:\n\n**Completed:**\n{{completed}}\n\n**In Progress:**\n{{inProgress}}\n\n**Blockers:**\n{{blockers}}',
+    variables: ['greeting', 'project', 'completed', 'inProgress', 'blockers'],
+    tone: 'professional' as Tone,
+  },
+  {
+    name: 'Apology',
+    category: 'personal',
+    body: 'Hi {{name}},\n\nI want to sincerely apologize for {{issue}}. {{explanation}}\n\nTo make this right, {{resolution}}.',
+    variables: ['name', 'issue', 'explanation', 'resolution'],
+    tone: 'formal' as Tone,
+  },
+] as const;
+
+export class TemplateEngine {
+  private templates: Map<string, Template> = new Map();
+
+  constructor() {
+    const ids = [
+      'meeting-follow-up',
+      'introduction',
+      'thank-you',
+      'cold-outreach',
+      'status-update',
+      'apology',
+    ];
+
+    for (let i = 0; i < BUILT_IN.length; i++) {
+      const builtin = BUILT_IN[i];
+      const template: Template = { id: ids[i], ...builtin };
+      this.templates.set(template.id, template);
+    }
+  }
+
+  register(template: Template): void {
+    this.templates.set(template.id, template);
+  }
+
+  get(id: string): Template | undefined {
+    return this.templates.get(id);
+  }
+
+  list(category?: string): Template[] {
+    const all = [...this.templates.values()];
+    if (category) {
+      return all.filter((t) => t.category === category);
+    }
+    return all;
+  }
+
+  render(templateId: string, variables: Record<string, string>): string {
+    const template = this.templates.get(templateId);
+    if (!template) {
+      throw new Error(`Template not found: ${templateId}`);
+    }
+
+    let result = template.body;
+    for (const [key, value] of Object.entries(variables)) {
+      result = result.replaceAll(`{{${key}}}`, value);
+    }
+
+    return result;
+  }
+}

package/src/types.ts

@@ -0,0 +1,47 @@
+export type Tone = 'formal' | 'professional' | 'casual' | 'brief' | 'friendly' | 'assertive';
+export type Platform = 'email' | 'slack' | 'linkedin' | 'twitter' | 'reddit' | 'generic';
+
+export interface ComposeRequest {
+  content?: string;
+  context: ComposeContext;
+  instruction?: string;
+}
+
+export interface ComposeContext {
+  platform: Platform;
+  audience?: string;
+  tone?: Tone;
+  replyTo?: string;
+  maxLength?: number;
+}
+
+export interface ComposeResult {
+  text: string;
+  tone: Tone;
+  platform: Platform;
+  wordCount: number;
+  characterCount: number;
+}
+
+export interface Template {
+  id: string;
+  name: string;
+  category: string;
+  body: string;
+  variables: string[];
+  tone: Tone;
+}
+
+export interface GrammarIssue {
+  type: 'spelling' | 'grammar' | 'style' | 'clarity';
+  message: string;
+  position: { start: number; end: number };
+  suggestion?: string;
+  severity: 'error' | 'warning' | 'info';
+}
+
+export interface LanguageResult {
+  language: string;
+  confidence: number;
+  script?: string;
+}

package/tests/composer.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { ComposeEngine } from '../src/composer.js';
+
+describe('ComposeEngine', () => {
+  const engine = new ComposeEngine();
+
+  it('compose returns ComposeResult with text', () => {
+    const result = engine.compose({
+      content: 'Hello world',
+      context: { platform: 'slack' },
+    });
+    expect(result.text).toContain('Hello world');
+    expect(result.platform).toBe('slack');
+  });
+
+  it('adaptToneForPlatform email returns formal', () => {
+    const result = engine.compose({
+      content: 'Test',
+      context: { platform: 'email' },
+    });
+    expect(result.tone).toBe('formal');
+  });
+
+  it('adaptToneForPlatform slack returns casual', () => {
+    const result = engine.compose({
+      content: 'Test',
+      context: { platform: 'slack' },
+    });
+    expect(result.tone).toBe('casual');
+  });
+
+  it('adaptToneForPlatform twitter returns brief', () => {
+    const result = engine.compose({
+      content: 'Test',
+      context: { platform: 'twitter' },
+    });
+    expect(result.tone).toBe('brief');
+  });
+
+  it('twitter enforced to 280 chars', () => {
+    const longText = 'A'.repeat(300);
+    const result = engine.compose({
+      content: longText,
+      context: { platform: 'twitter' },
+    });
+    expect(result.text.length).toBeLessThanOrEqual(280);
+    expect(result.text.endsWith('...')).toBe(true);
+  });
+
+  it('sign-off added for email', () => {
+    const result = engine.compose({
+      content: 'Hello there',
+      context: { platform: 'email' },
+    });
+    expect(result.text).toContain('Best regards,');
+  });
+
+  it('no sign-off for twitter', () => {
+    const result = engine.compose({
+      content: 'Hello there',
+      context: { platform: 'twitter' },
+    });
+    expect(result.text).toBe('Hello there');
+  });
+
+  it('wordCount is accurate', () => {
+    const result = engine.compose({
+      content: 'one two three four five',
+      context: { platform: 'slack' },
+    });
+    expect(result.wordCount).toBe(5);
+  });
+
+  it('characterCount is accurate', () => {
+    const result = engine.compose({
+      content: 'hello',
+      context: { platform: 'slack' },
+    });
+    expect(result.characterCount).toBe(5);
+  });
+
+  it('explicit tone overrides platform default', () => {
+    const result = engine.compose({
+      content: 'Test',
+      context: { platform: 'email', tone: 'casual' },
+    });
+    expect(result.tone).toBe('casual');
+  });
+});

package/tests/grammar.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { GrammarChecker } from '../src/grammar.js';
+
+describe('GrammarChecker', () => {
+  const checker = new GrammarChecker();
+
+  it('detects double spaces', () => {
+    const issues = checker.check('Hello  world.');
+    expect(issues.some((i) => i.message === 'Double space detected')).toBe(true);
+  });
+
+  it('detects repeated words', () => {
+    const issues = checker.check('The the cat sat.');
+    expect(issues.some((i) => i.message.includes('Repeated word'))).toBe(true);
+  });
+
+  it('detects long sentences (>40 words)', () => {
+    const words = Array.from({ length: 45 }, (_, i) => `word${i}`).join(' ') + '.';
+    const issues = checker.check(words);
+    expect(issues.some((i) => i.message.includes('words long'))).toBe(true);
+  });
+
+  it('detects passive voice pattern', () => {
+    const issues = checker.check('The report was completed yesterday.');
+    expect(issues.some((i) => i.message === 'Possible passive voice')).toBe(true);
+  });
+
+  it('detects weasel words', () => {
+    const issues = checker.check('This is very important.');
+    expect(issues.some((i) => i.message.includes('Weasel word'))).toBe(true);
+  });
+
+  it('detects missing period', () => {
+    const issues = checker.check('Hello world');
+    expect(issues.some((i) => i.message === 'Text does not end with punctuation')).toBe(true);
+  });
+
+  it('returns empty for clean text', () => {
+    const issues = checker.check('The cat sat on the mat.');
+    expect(issues.length).toBe(0);
+  });
+
+  it('issues sorted by position', () => {
+    const issues = checker.check('The  the  cat is very nice');
+    for (let i = 1; i < issues.length; i++) {
+      expect(issues[i].position.start).toBeGreaterThanOrEqual(issues[i - 1].position.start);
+    }
+  });
+});

package/tests/language.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { LanguageDetector } from '../src/language.js';
+
+describe('LanguageDetector', () => {
+  const detector = new LanguageDetector();
+
+  it('detect English text', () => {
+    const result = detector.detect('The cat is sitting on the mat with this from that');
+    expect(result.language).toBe('english');
+    expect(result.confidence).toBeGreaterThan(0);
+  });
+
+  it('detect Spanish text', () => {
+    const result = detector.detect('El gato es un animal que los tiene en las casas por la noche');
+    expect(result.language).toBe('spanish');
+    expect(result.confidence).toBeGreaterThan(0);
+  });
+
+  it('detect French text', () => {
+    const result = detector.detect('Le chat est un animal que les gens ont dans une maison avec des amis');
+    expect(result.language).toBe('french');
+    expect(result.confidence).toBeGreaterThan(0);
+  });
+
+  it('detect German text', () => {
+    const result = detector.detect('Der Hund ist ein Tier und die Katze ist mit das Haus');
+    expect(result.language).toBe('german');
+    expect(result.confidence).toBeGreaterThan(0);
+  });
+
+  it('isRTL true for arabic', () => {
+    expect(detector.isRTL('arabic')).toBe(true);
+  });
+
+  it('isRTL false for english', () => {
+    expect(detector.isRTL('english')).toBe(false);
+  });
+});