@semiont/jobs 0.2.28-build.40

package/README.md

@@ -0,0 +1,552 @@
+# @semiont/jobs
+
+[![Tests](https://github.com/The-AI-Alliance/semiont/actions/workflows/package-tests.yml/badge.svg)](https://github.com/The-AI-Alliance/semiont/actions/workflows/package-tests.yml?query=branch%3Amain+is%3Asuccess+job%3A%22Test+jobs%22)
+[![npm version](https://img.shields.io/npm/v/@semiont/jobs.svg)](https://www.npmjs.com/package/@semiont/jobs)
+[![License](https://img.shields.io/npm/l/@semiont/jobs.svg)](https://github.com/The-AI-Alliance/semiont/blob/main/LICENSE)
+
+Filesystem-based job queue and worker infrastructure for [Semiont](https://github.com/The-AI-Alliance/semiont) - provides async job processing, background workers, and long-running task management.
+
+## What is a Job Queue?
+
+A job queue is a pattern for processing work asynchronously outside of the HTTP request/response cycle. Jobs are persisted to storage, processed by workers, and can be monitored for progress and completion.
+
+**Benefits:**
+- **Decoupled processing** - HTTP responses return immediately while work continues
+- **Reliability** - Jobs are persisted to disk and survive process restarts
+- **Progress tracking** - Long-running tasks can report status updates
+- **Retry logic** - Failed jobs can be retried with exponential backoff
+- **Scalability** - Multiple workers can process jobs concurrently
+
+## Installation
+
+```bash
+npm install @semiont/jobs
+```
+
+**Prerequisites:**
+- Node.js >= 20.18.1
+- `@semiont/core` and `@semiont/api-client` (peer dependencies)
+
+## Quick Start
+
+```typescript
+import {
+  JobQueue,
+  initializeJobQueue,
+  getJobQueue,
+  JobWorker,
+  type GenerationJob,
+} from '@semiont/jobs';
+import { jobId } from '@semiont/api-client';
+import { userId, resourceId } from '@semiont/core';
+
+// 1. Initialize job queue
+await initializeJobQueue({ dataDir: './data' });
+
+// 2. Create a job
+const jobQueue = getJobQueue();
+const job: GenerationJob = {
+  id: jobId('job-abc123'),
+  type: 'generation',
+  status: 'pending',
+  userId: userId('user@example.com'),
+  referenceId: annotationId('ref-123'),
+  sourceResourceId: resourceId('doc-456'),
+  title: 'Generated Article',
+  created: new Date().toISOString(),
+  retryCount: 0,
+  maxRetries: 3,
+};
+
+await jobQueue.createJob(job);
+
+// 3. Create a worker to process jobs
+class MyGenerationWorker extends JobWorker {
+  protected getWorkerName(): string {
+    return 'MyGenerationWorker';
+  }
+
+  protected canProcessJob(job: Job): boolean {
+    return job.type === 'generation';
+  }
+
+  protected async executeJob(job: Job): Promise<void> {
+    const genJob = job as GenerationJob;
+    console.log(`Generating resource: ${genJob.title}`);
+    // Your processing logic here
+  }
+}
+
+// 4. Start worker
+const worker = new MyGenerationWorker();
+await worker.start();
+```
+
+## Architecture
+
+The jobs package follows a simple status-directory pattern:
+
+```
+data/
+  jobs/
+    pending/        ← Jobs waiting to be processed
+      job-123.json
+      job-456.json
+    running/        ← Jobs currently being processed
+      job-789.json
+    complete/       ← Successfully completed jobs
+      job-111.json
+    failed/         ← Failed jobs (with error info)
+      job-222.json
+    cancelled/      ← Cancelled jobs
+      job-333.json
+```
+
+**Key Components:**
+
+- **JobQueue** - Manages job lifecycle and persistence
+- **JobWorker** - Abstract base class for workers that process jobs
+- **Job Types** - Strongly-typed job definitions for different task types
+
+## Core Concepts
+
+### Jobs
+
+Jobs are JSON documents that represent async work:
+
+```typescript
+import type { GenerationJob } from '@semiont/jobs';
+
+const job: GenerationJob = {
+  id: jobId('job-123'),
+  type: 'generation',
+  status: 'pending',
+  userId: userId('user@example.com'),
+
+  // Job-specific fields
+  referenceId: annotationId('ref-456'),
+  sourceResourceId: resourceId('doc-789'),
+  title: 'AI Generated Article',
+  prompt: 'Write about quantum computing',
+  language: 'en-US',
+
+  // Timestamps
+  created: '2024-01-01T00:00:00Z',
+  startedAt: undefined,      // Set when worker picks up job
+  completedAt: undefined,    // Set when job finishes
+
+  // Retry handling
+  retryCount: 0,
+  maxRetries: 3,
+  error: undefined,          // Set if job fails
+
+  // Progress tracking (optional)
+  progress: {
+    stage: 'generating',
+    percentage: 45,
+    message: 'Generating content...',
+  },
+
+  // Result (optional)
+  result: {
+    resourceId: resourceId('doc-new'),
+    resourceName: 'Generated Article',
+  },
+};
+```
+
+### Job Types
+
+The package supports multiple job types for different tasks:
+
+```typescript
+import type {
+  DetectionJob,           // Entity detection in resources
+  GenerationJob,          // AI content generation
+  HighlightDetectionJob,  // Identify key passages
+  AssessmentDetectionJob, // Generate evaluative comments
+  CommentDetectionJob,    // Generate explanatory comments
+  TagDetectionJob,        // Structural role detection
+} from '@semiont/jobs';
+```
+
+### Job Status
+
+Jobs progress through status states stored as directories:
+
+```typescript
+type JobStatus =
+  | 'pending'    // Waiting to be processed
+  | 'running'    // Currently being processed
+  | 'complete'   // Successfully finished
+  | 'failed'     // Failed with error
+  | 'cancelled'  // Cancelled by user
+```
+
+### Workers
+
+Workers poll the queue and process jobs:
+
+```typescript
+import { JobWorker, type Job } from '@semiont/jobs';
+
+class CustomWorker extends JobWorker {
+  // Worker identification
+  protected getWorkerName(): string {
+    return 'CustomWorker';
+  }
+
+  // Filter which jobs this worker processes
+  protected canProcessJob(job: Job): boolean {
+    return job.type === 'custom-type';
+  }
+
+  // Implement job processing logic
+  protected async executeJob(job: Job): Promise<void> {
+    // 1. Access job data
+    const customJob = job as CustomJob;
+
+    // 2. Perform async work
+    const result = await doWork(customJob);
+
+    // 3. Update job with results
+    customJob.result = result;
+  }
+}
+```
+
+## Documentation
+
+📚 **[Job Queue Guide](./docs/JobQueue.md)** - JobQueue API and job management
+
+👷 **[Workers Guide](./docs/Workers.md)** - Building custom workers
+
+📝 **[Job Types Guide](./docs/JobTypes.md)** - All job type definitions and usage
+
+⚙️ **[Configuration Guide](./docs/Configuration.md)** - Setup and options
+
+## Key Features
+
+- **Type-safe** - Full TypeScript support with discriminated union types
+- **Filesystem-based** - No external database required (JSON files for jobs)
+- **Status directories** - Jobs organized by status for easy polling
+- **Atomic operations** - Safe concurrent access to job files
+- **Progress tracking** - Jobs can report progress updates during processing
+- **Retry logic** - Built-in retry handling with configurable max attempts
+- **Framework-agnostic** - Pure TypeScript, no web framework dependencies
+
+## Use Cases
+
+✅ **AI generation** - Long-running LLM inference tasks
+
+✅ **Background processing** - Resource analysis, entity detection
+
+✅ **Worker microservices** - Separate processes for compute-intensive work
+
+✅ **CLI tools** - Command-line tools that queue batch operations
+
+✅ **Testing** - Isolated job queues for unit/integration tests
+
+❌ **Not for frontend** - Backend infrastructure only (workers need filesystem access)
+
+## API Overview
+
+### JobQueue
+
+```typescript
+const queue = getJobQueue();
+
+// Create job
+await queue.createJob(job);
+
+// Get job by ID
+const job = await queue.getJob(jobId);
+
+// Poll for next pending job
+const next = await queue.pollNextPendingJob();
+
+// Update job status
+job.status = 'complete';
+await queue.updateJob(job, 'running');
+
+// Query jobs by status
+const pending = await queue.queryJobs({ status: 'pending' });
+const failed = await queue.queryJobs({ status: 'failed' });
+
+// Cleanup old jobs
+await queue.cleanupCompletedJobs(Date.now() - 86400000); // 1 day ago
+```
+
+### JobWorker
+
+```typescript
+// Create worker
+class MyWorker extends JobWorker {
+  constructor() {
+    super(
+      1000,  // Poll interval (ms)
+      5000   // Error backoff (ms)
+    );
+  }
+
+  protected getWorkerName(): string {
+    return 'MyWorker';
+  }
+
+  protected canProcessJob(job: Job): boolean {
+    return job.type === 'my-type';
+  }
+
+  protected async executeJob(job: Job): Promise<void> {
+    // Process job
+  }
+}
+
+// Start worker
+const worker = new MyWorker();
+await worker.start();
+
+// Stop worker (graceful shutdown)
+await worker.stop();
+```
+
+### Singleton Pattern
+
+```typescript
+import { initializeJobQueue, getJobQueue } from '@semiont/jobs';
+
+// Initialize once at startup
+await initializeJobQueue({ dataDir: './data' });
+
+// Get queue instance anywhere
+const queue = getJobQueue();
+```
+
+## Storage Format
+
+Jobs are stored as individual JSON files:
+
+```
+data/
+  jobs/
+    pending/
+      job-abc123.json
+    running/
+      job-def456.json
+    complete/
+      job-ghi789.json
+```
+
+Each job file contains the complete job object:
+
+```json
+{
+  "id": "job-abc123",
+  "type": "generation",
+  "status": "complete",
+  "userId": "user@example.com",
+  "referenceId": "ref-456",
+  "sourceResourceId": "doc-789",
+  "title": "Generated Article",
+  "created": "2024-01-01T00:00:00Z",
+  "startedAt": "2024-01-01T00:01:00Z",
+  "completedAt": "2024-01-01T00:05:00Z",
+  "retryCount": 0,
+  "maxRetries": 3,
+  "result": {
+    "resourceId": "doc-new",
+    "resourceName": "Generated Article"
+  }
+}
+```
+
+## Performance
+
+- **Polling-based** - Workers poll pending directory at configurable intervals
+- **Filesystem limits** - Performance degrades with >1000 pending jobs per directory
+- **Atomic moves** - Jobs move between status directories atomically (delete + write)
+- **No locks needed** - Status-based organization prevents race conditions
+
+**Scaling considerations:**
+- Multiple workers can run concurrently (same or different machines)
+- Workers use `pollNextPendingJob()` for FIFO processing
+- Completed jobs should be cleaned up periodically
+- For high throughput (>1000 jobs/min), consider Redis/database-backed queue
+
+## Error Handling
+
+### Worker Error Recovery
+
+```typescript
+class ResilientWorker extends JobWorker {
+  protected async executeJob(job: Job): Promise<void> {
+    try {
+      await doWork(job);
+    } catch (error) {
+      // JobWorker base class handles:
+      // 1. Moving job to 'failed' status
+      // 2. Recording error message
+      // 3. Retry logic (if retryCount < maxRetries)
+      throw error; // Let base class handle it
+    }
+  }
+}
+```
+
+### Manual Retry
+
+```typescript
+const queue = getJobQueue();
+const failedJobs = await queue.queryJobs({ status: 'failed' });
+
+for (const job of failedJobs) {
+  if (job.retryCount < job.maxRetries) {
+    job.status = 'pending';
+    job.retryCount++;
+    delete job.error;
+    await queue.updateJob(job, 'failed');
+  }
+}
+```
+
+## Testing
+
+```typescript
+import { initializeJobQueue, getJobQueue } from '@semiont/jobs';
+import { describe, it, beforeEach } from 'vitest';
+
+describe('Job queue', () => {
+  beforeEach(async () => {
+    await initializeJobQueue({ dataDir: './test-data' });
+  });
+
+  it('should create and retrieve jobs', async () => {
+    const queue = getJobQueue();
+
+    const job: GenerationJob = {
+      id: jobId('test-1'),
+      type: 'generation',
+      status: 'pending',
+      // ... other fields
+    };
+
+    await queue.createJob(job);
+    const retrieved = await queue.getJob(jobId('test-1'));
+
+    expect(retrieved).toEqual(job);
+  });
+});
+```
+
+## Examples
+
+### Building a Background Worker
+
+```typescript
+import { JobWorker, type Job, type GenerationJob } from '@semiont/jobs';
+import { InferenceService } from './inference';
+
+class GenerationWorker extends JobWorker {
+  private inference: InferenceService;
+
+  constructor(inference: InferenceService) {
+    super(1000, 5000);
+    this.inference = inference;
+  }
+
+  protected getWorkerName(): string {
+    return 'GenerationWorker';
+  }
+
+  protected canProcessJob(job: Job): boolean {
+    return job.type === 'generation';
+  }
+
+  protected async executeJob(job: Job): Promise<void> {
+    const genJob = job as GenerationJob;
+
+    // Report progress
+    genJob.progress = {
+      stage: 'generating',
+      percentage: 0,
+      message: 'Starting generation...',
+    };
+    await getJobQueue().updateJob(genJob);
+
+    // Generate content
+    const content = await this.inference.generate({
+      prompt: genJob.prompt,
+      context: genJob.context,
+      temperature: genJob.temperature,
+      maxTokens: genJob.maxTokens,
+    });
+
+    // Update progress
+    genJob.progress = {
+      stage: 'creating',
+      percentage: 75,
+      message: 'Creating resource...',
+    };
+    await getJobQueue().updateJob(genJob);
+
+    // Create resource (simplified)
+    const resourceId = await createResource(content, genJob.title);
+
+    // Set result
+    genJob.result = {
+      resourceId,
+      resourceName: genJob.title,
+    };
+  }
+}
+```
+
+### Progress Monitoring
+
+```typescript
+import { getJobQueue } from '@semiont/jobs';
+
+async function monitorJob(jobId: JobId): Promise<void> {
+  const queue = getJobQueue();
+
+  while (true) {
+    const job = await queue.getJob(jobId);
+
+    if (!job) {
+      console.log('Job not found');
+      break;
+    }
+
+    console.log(`Status: ${job.status}`);
+
+    if (job.progress) {
+      console.log(`Progress: ${job.progress.percentage}%`);
+      console.log(`Stage: ${job.progress.stage}`);
+      console.log(`Message: ${job.progress.message}`);
+    }
+
+    if (job.status === 'complete' || job.status === 'failed') {
+      break;
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+}
+```
+
+## License
+
+Apache-2.0
+
+## Related Packages
+
+- [`@semiont/api-client`](../api-client/) - API types and utilities
+- [`@semiont/core`](../core/) - Domain types and utilities
+- [`@semiont/event-sourcing`](../event-sourcing/) - Event persistence
+- [`semiont-backend`](../../apps/backend/) - Backend API server
+
+## Learn More
+
+- [Background Jobs Pattern](https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageQueueing.html) - Queue-based processing
+- [Job Types Guide](./docs/JobTypes.md) - Detailed job type documentation
+- [Workers Guide](./docs/Workers.md) - Building custom workers

package/dist/index.d.ts

@@ -0,0 +1,286 @@
+import { JobId, EntityType, GenerationContext } from '@semiont/api-client';
+import { UserId, ResourceId, AnnotationId } from '@semiont/core';
+
+/**
+ * Job Queue Type Definitions
+ *
+ * Jobs represent async work that can be queued, processed, and monitored.
+ * They are completely independent of HTTP request/response cycles.
+ */
+
+type JobType = 'detection' | 'generation' | 'highlight-detection' | 'assessment-detection' | 'comment-detection' | 'tag-detection';
+type JobStatus = 'pending' | 'running' | 'complete' | 'failed' | 'cancelled';
+/**
+ * Base job interface - all jobs extend this
+ */
+interface BaseJob {
+    id: JobId;
+    type: JobType;
+    status: JobStatus;
+    userId: UserId;
+    created: string;
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+    retryCount: number;
+    maxRetries: number;
+}
+/**
+ * Detection job - finds entities in a resource using AI inference
+ */
+interface DetectionJob extends BaseJob {
+    type: 'detection';
+    resourceId: ResourceId;
+    entityTypes: EntityType[];
+    includeDescriptiveReferences?: boolean;
+    progress?: {
+        totalEntityTypes: number;
+        processedEntityTypes: number;
+        currentEntityType?: string;
+        entitiesFound: number;
+        entitiesEmitted: number;
+    };
+    result?: {
+        totalFound: number;
+        totalEmitted: number;
+        errors: number;
+    };
+}
+/**
+ * Generation job - generates a new resource using AI inference
+ */
+interface GenerationJob extends BaseJob {
+    type: 'generation';
+    referenceId: AnnotationId;
+    sourceResourceId: ResourceId;
+    prompt?: string;
+    title?: string;
+    entityTypes?: EntityType[];
+    language?: string;
+    context?: GenerationContext;
+    temperature?: number;
+    maxTokens?: number;
+    progress?: {
+        stage: 'fetching' | 'generating' | 'creating' | 'linking';
+        percentage: number;
+        message?: string;
+    };
+    result?: {
+        resourceId: ResourceId;
+        resourceName: string;
+    };
+}
+/**
+ * Highlight Detection job - finds passages to highlight using AI
+ */
+interface HighlightDetectionJob extends BaseJob {
+    type: 'highlight-detection';
+    resourceId: ResourceId;
+    instructions?: string;
+    density?: number;
+    progress?: {
+        stage: 'analyzing' | 'creating';
+        percentage: number;
+        message?: string;
+    };
+    result?: {
+        highlightsFound: number;
+        highlightsCreated: number;
+    };
+}
+/**
+ * Assessment Detection job - evaluates passages using AI
+ */
+interface AssessmentDetectionJob extends BaseJob {
+    type: 'assessment-detection';
+    resourceId: ResourceId;
+    instructions?: string;
+    tone?: 'analytical' | 'critical' | 'balanced' | 'constructive';
+    density?: number;
+    progress?: {
+        stage: 'analyzing' | 'creating';
+        percentage: number;
+        message?: string;
+    };
+    result?: {
+        assessmentsFound: number;
+        assessmentsCreated: number;
+    };
+}
+/**
+ * Comment Detection job - generates explanatory comments on passages using AI
+ */
+interface CommentDetectionJob extends BaseJob {
+    type: 'comment-detection';
+    resourceId: ResourceId;
+    instructions?: string;
+    tone?: 'scholarly' | 'explanatory' | 'conversational' | 'technical';
+    density?: number;
+    progress?: {
+        stage: 'analyzing' | 'creating';
+        percentage: number;
+        message?: string;
+    };
+    result?: {
+        commentsFound: number;
+        commentsCreated: number;
+    };
+}
+/**
+ * Tag Detection job - identifies passages serving structural roles using AI
+ */
+interface TagDetectionJob extends BaseJob {
+    type: 'tag-detection';
+    resourceId: ResourceId;
+    schemaId: string;
+    categories: string[];
+    progress?: {
+        stage: 'analyzing' | 'creating';
+        percentage: number;
+        currentCategory?: string;
+        processedCategories: number;
+        totalCategories: number;
+        message?: string;
+    };
+    result?: {
+        tagsFound: number;
+        tagsCreated: number;
+        byCategory: Record<string, number>;
+    };
+}
+/**
+ * Discriminated union of all job types
+ */
+type Job = DetectionJob | GenerationJob | HighlightDetectionJob | AssessmentDetectionJob | CommentDetectionJob | TagDetectionJob;
+/**
+ * Job query filters
+ */
+interface JobQueryFilters {
+    status?: JobStatus;
+    type?: JobType;
+    userId?: UserId;
+    limit?: number;
+    offset?: number;
+}
+
+/**
+ * Job Queue Manager
+ *
+ * Filesystem-based job queue with atomic operations.
+ * Jobs are stored in directories by status for easy polling.
+ */
+
+interface JobQueueConfig {
+    dataDir: string;
+}
+declare class JobQueue {
+    private jobsDir;
+    constructor(config: JobQueueConfig);
+    /**
+     * Initialize job queue directories
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create a new job
+     */
+    createJob(job: Job): Promise<void>;
+    /**
+     * Get a job by ID (searches all status directories)
+     */
+    getJob(jobId: JobId): Promise<Job | null>;
+    /**
+     * Update a job (atomic: delete old, write new)
+     */
+    updateJob(job: Job, oldStatus?: JobStatus): Promise<void>;
+    /**
+     * Poll for next pending job (FIFO)
+     */
+    pollNextPendingJob(): Promise<Job | null>;
+    /**
+     * List jobs with filters
+     */
+    listJobs(filters?: JobQueryFilters): Promise<Job[]>;
+    /**
+     * Cancel a job
+     */
+    cancelJob(jobId: JobId): Promise<boolean>;
+    /**
+     * Clean up old completed/failed jobs (older than retention period)
+     */
+    cleanupOldJobs(retentionHours?: number): Promise<number>;
+    /**
+     * Get job file path
+     */
+    private getJobPath;
+    /**
+     * Get statistics about the queue
+     */
+    getStats(): Promise<{
+        pending: number;
+        running: number;
+        complete: number;
+        failed: number;
+        cancelled: number;
+    }>;
+}
+declare function getJobQueue(): JobQueue;
+declare function initializeJobQueue(config: JobQueueConfig): Promise<JobQueue>;
+
+/**
+ * Job Worker Base Class
+ *
+ * Abstract worker that polls the job queue and processes jobs.
+ * Subclasses implement specific job processing logic.
+ */
+
+declare abstract class JobWorker {
+    private running;
+    private currentJob;
+    private pollIntervalMs;
+    private errorBackoffMs;
+    constructor(pollIntervalMs?: number, errorBackoffMs?: number);
+    /**
+     * Start the worker (polls queue in loop)
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the worker (graceful shutdown)
+     */
+    stop(): Promise<void>;
+    /**
+     * Poll for next job to process
+     */
+    private pollNextJob;
+    /**
+     * Process a job (handles state transitions and error handling)
+     */
+    private processJob;
+    /**
+     * Handle job failure (retry or move to failed)
+     */
+    protected handleJobFailure(job: Job, error: any): Promise<void>;
+    /**
+     * Update job progress (best-effort, doesn't throw)
+     */
+    protected updateJobProgress(job: Job): Promise<void>;
+    /**
+     * Sleep utility
+     */
+    protected sleep(ms: number): Promise<void>;
+    /**
+     * Get worker name (for logging)
+     */
+    protected abstract getWorkerName(): string;
+    /**
+     * Check if this worker can process the given job
+     */
+    protected abstract canProcessJob(job: Job): boolean;
+    /**
+     * Execute the job (job-specific logic)
+     * This is where the actual work happens
+     * Throw an error to trigger retry logic
+     */
+    protected abstract executeJob(job: Job): Promise<void>;
+}
+
+export { type AssessmentDetectionJob, type BaseJob, type CommentDetectionJob, type DetectionJob, type GenerationJob, type HighlightDetectionJob, type Job, type JobQueryFilters, JobQueue, type JobQueueConfig, type JobStatus, type JobType, JobWorker, type TagDetectionJob, getJobQueue, initializeJobQueue };

package/dist/index.js

@@ -0,0 +1,325 @@
+import { promises } from 'fs';
+import * as path from 'path';
+
+// src/job-queue.ts
+var JobQueue = class {
+  jobsDir;
+  constructor(config) {
+    this.jobsDir = path.join(config.dataDir, "jobs");
+  }
+  /**
+   * Initialize job queue directories
+   */
+  async initialize() {
+    const statuses = ["pending", "running", "complete", "failed", "cancelled"];
+    for (const status of statuses) {
+      const dir = path.join(this.jobsDir, status);
+      await promises.mkdir(dir, { recursive: true });
+    }
+    console.log("[JobQueue] Initialized job directories");
+  }
+  /**
+   * Create a new job
+   */
+  async createJob(job) {
+    const jobPath = this.getJobPath(job.id, job.status);
+    await promises.writeFile(jobPath, JSON.stringify(job, null, 2), "utf-8");
+    console.log(`[JobQueue] Created job ${job.id} with status ${job.status}`);
+  }
+  /**
+   * Get a job by ID (searches all status directories)
+   */
+  async getJob(jobId) {
+    const statuses = ["pending", "running", "complete", "failed", "cancelled"];
+    for (const status of statuses) {
+      const jobPath = this.getJobPath(jobId, status);
+      try {
+        const content = await promises.readFile(jobPath, "utf-8");
+        return JSON.parse(content);
+      } catch (error) {
+        continue;
+      }
+    }
+    return null;
+  }
+  /**
+   * Update a job (atomic: delete old, write new)
+   */
+  async updateJob(job, oldStatus) {
+    if (oldStatus && oldStatus !== job.status) {
+      const oldPath = this.getJobPath(job.id, oldStatus);
+      try {
+        await promises.unlink(oldPath);
+      } catch (error) {
+      }
+    }
+    const newPath = this.getJobPath(job.id, job.status);
+    await promises.writeFile(newPath, JSON.stringify(job, null, 2), "utf-8");
+    if (oldStatus && oldStatus !== job.status) {
+      console.log(`[JobQueue] Moved job ${job.id} from ${oldStatus} to ${job.status}`);
+    } else {
+      console.log(`[JobQueue] Updated job ${job.id} (status: ${job.status})`);
+    }
+  }
+  /**
+   * Poll for next pending job (FIFO)
+   */
+  async pollNextPendingJob() {
+    const pendingDir = path.join(this.jobsDir, "pending");
+    try {
+      const files = await promises.readdir(pendingDir);
+      if (files.length === 0) {
+        return null;
+      }
+      files.sort();
+      const jobFile = files[0];
+      const jobPath = path.join(pendingDir, jobFile);
+      const content = await promises.readFile(jobPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      console.error("[JobQueue] Error polling pending jobs:", error);
+      return null;
+    }
+  }
+  /**
+   * List jobs with filters
+   */
+  async listJobs(filters = {}) {
+    const jobs = [];
+    const statuses = filters.status ? [filters.status] : ["pending", "running", "complete", "failed", "cancelled"];
+    for (const status of statuses) {
+      const statusDir = path.join(this.jobsDir, status);
+      try {
+        const files = await promises.readdir(statusDir);
+        for (const file of files) {
+          const jobPath = path.join(statusDir, file);
+          const content = await promises.readFile(jobPath, "utf-8");
+          const job = JSON.parse(content);
+          if (filters.type && job.type !== filters.type) continue;
+          if (filters.userId && job.userId !== filters.userId) continue;
+          jobs.push(job);
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    jobs.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+    const offset = filters.offset || 0;
+    const limit = filters.limit || 100;
+    return jobs.slice(offset, offset + limit);
+  }
+  /**
+   * Cancel a job
+   */
+  async cancelJob(jobId) {
+    const job = await this.getJob(jobId);
+    if (!job) {
+      return false;
+    }
+    if (job.status !== "pending" && job.status !== "running") {
+      return false;
+    }
+    const oldStatus = job.status;
+    job.status = "cancelled";
+    job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.updateJob(job, oldStatus);
+    return true;
+  }
+  /**
+   * Clean up old completed/failed jobs (older than retention period)
+   */
+  async cleanupOldJobs(retentionHours = 24) {
+    const cutoffTime = Date.now() - retentionHours * 60 * 60 * 1e3;
+    let deletedCount = 0;
+    const cleanupStatuses = ["complete", "failed", "cancelled"];
+    for (const status of cleanupStatuses) {
+      const statusDir = path.join(this.jobsDir, status);
+      try {
+        const files = await promises.readdir(statusDir);
+        for (const file of files) {
+          const jobPath = path.join(statusDir, file);
+          const content = await promises.readFile(jobPath, "utf-8");
+          const job = JSON.parse(content);
+          if (job.completedAt) {
+            const completedTime = new Date(job.completedAt).getTime();
+            if (completedTime < cutoffTime) {
+              await promises.unlink(jobPath);
+              deletedCount++;
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`[JobQueue] Error cleaning up ${status} jobs:`, error);
+      }
+    }
+    if (deletedCount > 0) {
+      console.log(`[JobQueue] Cleaned up ${deletedCount} old jobs`);
+    }
+    return deletedCount;
+  }
+  /**
+   * Get job file path
+   */
+  getJobPath(jobId, status) {
+    return path.join(this.jobsDir, status, `${jobId}.json`);
+  }
+  /**
+   * Get statistics about the queue
+   */
+  async getStats() {
+    const stats = {
+      pending: 0,
+      running: 0,
+      complete: 0,
+      failed: 0,
+      cancelled: 0
+    };
+    const statuses = ["pending", "running", "complete", "failed", "cancelled"];
+    for (const status of statuses) {
+      const statusDir = path.join(this.jobsDir, status);
+      try {
+        const files = await promises.readdir(statusDir);
+        stats[status] = files.length;
+      } catch (error) {
+        stats[status] = 0;
+      }
+    }
+    return stats;
+  }
+};
+var jobQueue = null;
+function getJobQueue() {
+  if (!jobQueue) {
+    throw new Error("JobQueue not initialized. Call initializeJobQueue() first.");
+  }
+  return jobQueue;
+}
+async function initializeJobQueue(config) {
+  jobQueue = new JobQueue(config);
+  await jobQueue.initialize();
+  return jobQueue;
+}
+
+// src/job-worker.ts
+var JobWorker = class {
+  running = false;
+  currentJob = null;
+  pollIntervalMs;
+  errorBackoffMs;
+  constructor(pollIntervalMs = 1e3, errorBackoffMs = 5e3) {
+    this.pollIntervalMs = pollIntervalMs;
+    this.errorBackoffMs = errorBackoffMs;
+  }
+  /**
+   * Start the worker (polls queue in loop)
+   */
+  async start() {
+    this.running = true;
+    console.log(`[${this.getWorkerName()}] Started`);
+    while (this.running) {
+      try {
+        const job = await this.pollNextJob();
+        if (job) {
+          await this.processJob(job);
+        } else {
+          await this.sleep(this.pollIntervalMs);
+        }
+      } catch (error) {
+        console.error(`[${this.getWorkerName()}] Error in main loop:`, error);
+        await this.sleep(this.errorBackoffMs);
+      }
+    }
+    console.log(`[${this.getWorkerName()}] Stopped`);
+  }
+  /**
+   * Stop the worker (graceful shutdown)
+   */
+  async stop() {
+    console.log(`[${this.getWorkerName()}] Stopping...`);
+    this.running = false;
+    const timeout = 6e4;
+    const startTime = Date.now();
+    while (this.currentJob && Date.now() - startTime < timeout) {
+      await this.sleep(100);
+    }
+    if (this.currentJob) {
+      console.warn(`[${this.getWorkerName()}] Forced shutdown while processing job ${this.currentJob.id}`);
+    }
+  }
+  /**
+   * Poll for next job to process
+   */
+  async pollNextJob() {
+    const jobQueue2 = getJobQueue();
+    const job = await jobQueue2.pollNextPendingJob();
+    if (job && this.canProcessJob(job)) {
+      return job;
+    }
+    return null;
+  }
+  /**
+   * Process a job (handles state transitions and error handling)
+   */
+  async processJob(job) {
+    this.currentJob = job;
+    const jobQueue2 = getJobQueue();
+    try {
+      const oldStatus = job.status;
+      job.status = "running";
+      job.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await jobQueue2.updateJob(job, oldStatus);
+      console.log(`[${this.getWorkerName()}] \u{1F504} Processing job ${job.id} (type: ${job.type})`);
+      await this.executeJob(job);
+      job.status = "complete";
+      job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await jobQueue2.updateJob(job, "running");
+      console.log(`[${this.getWorkerName()}] \u2705 Job ${job.id} completed successfully`);
+    } catch (error) {
+      await this.handleJobFailure(job, error);
+    } finally {
+      this.currentJob = null;
+    }
+  }
+  /**
+   * Handle job failure (retry or move to failed)
+   */
+  async handleJobFailure(job, error) {
+    const jobQueue2 = getJobQueue();
+    job.retryCount++;
+    if (job.retryCount < job.maxRetries) {
+      console.log(`[${this.getWorkerName()}] Job ${job.id} failed, will retry (${job.retryCount}/${job.maxRetries})`);
+      console.log(`[${this.getWorkerName()}] Error:`, error);
+      job.status = "pending";
+      job.startedAt = void 0;
+      await jobQueue2.updateJob(job, "running");
+    } else {
+      console.error(`[${this.getWorkerName()}] \u274C Job ${job.id} failed permanently after ${job.retryCount} retries`);
+      console.error(`[${this.getWorkerName()}] Error:`, error);
+      job.status = "failed";
+      job.error = error instanceof Error ? error.message : String(error);
+      job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await jobQueue2.updateJob(job, "running");
+    }
+  }
+  /**
+   * Update job progress (best-effort, doesn't throw)
+   */
+  async updateJobProgress(job) {
+    try {
+      const jobQueue2 = getJobQueue();
+      await jobQueue2.updateJob(job);
+    } catch (error) {
+      console.warn(`[${this.getWorkerName()}] Failed to update job progress:`, error);
+    }
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+export { JobQueue, JobWorker, getJobQueue, initializeJobQueue };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/job-queue.ts","../src/job-worker.ts"],"names":["fs","jobQueue"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Job Queue Manager\n *\n * Filesystem-based job queue with atomic operations.\n * Jobs are stored in directories by status for easy polling.\n */\n\nimport { promises as fs } from 'fs';\nimport * as path from 'path';\nimport type { Job, JobStatus, JobQueryFilters } from './types';\nimport type { JobId } from '@semiont/api-client';\n\nexport interface JobQueueConfig {\n  dataDir: string;\n}\n\nexport class JobQueue {\n  private jobsDir: string;\n\n  constructor(config: JobQueueConfig) {\n    this.jobsDir = path.join(config.dataDir, 'jobs');\n  }\n\n  /**\n   * Initialize job queue directories\n   */\n  async initialize(): Promise<void> {\n    const statuses: JobStatus[] = ['pending', 'running', 'complete', 'failed', 'cancelled'];\n\n    for (const status of statuses) {\n      const dir = path.join(this.jobsDir, status);\n      await fs.mkdir(dir, { recursive: true });\n    }\n\n    console.log('[JobQueue] Initialized job directories');\n  }\n\n  /**\n   * Create a new job\n   */\n  async createJob(job: Job): Promise<void> {\n    const jobPath = this.getJobPath(job.id, job.status);\n    await fs.writeFile(jobPath, JSON.stringify(job, null, 2), 'utf-8');\n    console.log(`[JobQueue] Created job ${job.id} with status ${job.status}`);\n  }\n\n  /**\n   * Get a job by ID (searches all status directories)\n   */\n  async getJob(jobId: JobId): Promise<Job | null> {\n    const statuses: JobStatus[] = ['pending', 'running', 'complete', 'failed', 'cancelled'];\n\n    for (const status of statuses) {\n      const jobPath = this.getJobPath(jobId, status);\n      try {\n        const content = await fs.readFile(jobPath, 'utf-8');\n        return JSON.parse(content) as Job;\n      } catch (error) {\n        // File doesn't exist in this status directory, try next\n        continue;\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Update a job (atomic: delete old, write new)\n   */\n  async updateJob(job: Job, oldStatus?: JobStatus): Promise<void> {\n    // If oldStatus provided, delete from old location\n    if (oldStatus && oldStatus !== job.status) {\n      const oldPath = this.getJobPath(job.id, oldStatus);\n      try {\n        await fs.unlink(oldPath);\n      } catch (error) {\n        // Ignore if file doesn't exist\n      }\n    }\n\n    // Write to new location\n    const newPath = this.getJobPath(job.id, job.status);\n    await fs.writeFile(newPath, JSON.stringify(job, null, 2), 'utf-8');\n\n    if (oldStatus && oldStatus !== job.status) {\n      console.log(`[JobQueue] Moved job ${job.id} from ${oldStatus} to ${job.status}`);\n    } else {\n      console.log(`[JobQueue] Updated job ${job.id} (status: ${job.status})`);\n    }\n  }\n\n  /**\n   * Poll for next pending job (FIFO)\n   */\n  async pollNextPendingJob(): Promise<Job | null> {\n    const pendingDir = path.join(this.jobsDir, 'pending');\n\n    try {\n      const files = await fs.readdir(pendingDir);\n\n      if (files.length === 0) {\n        return null;\n      }\n\n      // Sort by filename (job IDs have timestamps via nanoid)\n      files.sort();\n\n      const jobFile = files[0]!;\n      const jobPath = path.join(pendingDir, jobFile);\n\n      const content = await fs.readFile(jobPath, 'utf-8');\n      return JSON.parse(content) as Job;\n    } catch (error) {\n      console.error('[JobQueue] Error polling pending jobs:', error);\n      return null;\n    }\n  }\n\n  /**\n   * List jobs with filters\n   */\n  async listJobs(filters: JobQueryFilters = {}): Promise<Job[]> {\n    const jobs: Job[] = [];\n\n    // Determine which status directories to scan\n    const statuses: JobStatus[] = filters.status\n      ? [filters.status]\n      : ['pending', 'running', 'complete', 'failed', 'cancelled'];\n\n    for (const status of statuses) {\n      const statusDir = path.join(this.jobsDir, status);\n\n      try {\n        const files = await fs.readdir(statusDir);\n\n        for (const file of files) {\n          const jobPath = path.join(statusDir, file);\n          const content = await fs.readFile(jobPath, 'utf-8');\n          const job = JSON.parse(content) as Job;\n\n          // Apply filters\n          if (filters.type && job.type !== filters.type) continue;\n          if (filters.userId && job.userId !== filters.userId) continue;\n\n          jobs.push(job);\n        }\n      } catch (error) {\n        // Directory might not exist yet\n        continue;\n      }\n    }\n\n    // Sort by created descending (newest first)\n    jobs.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());\n\n    // Apply pagination\n    const offset = filters.offset || 0;\n    const limit = filters.limit || 100;\n\n    return jobs.slice(offset, offset + limit);\n  }\n\n  /**\n   * Cancel a job\n   */\n  async cancelJob(jobId: JobId): Promise<boolean> {\n    const job = await this.getJob(jobId);\n\n    if (!job) {\n      return false;\n    }\n\n    // Can only cancel pending or running jobs\n    if (job.status !== 'pending' && job.status !== 'running') {\n      return false;\n    }\n\n    const oldStatus = job.status;\n    job.status = 'cancelled';\n    job.completedAt = new Date().toISOString();\n\n    await this.updateJob(job, oldStatus);\n    return true;\n  }\n\n  /**\n   * Clean up old completed/failed jobs (older than retention period)\n   */\n  async cleanupOldJobs(retentionHours: number = 24): Promise<number> {\n    const cutoffTime = Date.now() - (retentionHours * 60 * 60 * 1000);\n    let deletedCount = 0;\n\n    const cleanupStatuses: JobStatus[] = ['complete', 'failed', 'cancelled'];\n\n    for (const status of cleanupStatuses) {\n      const statusDir = path.join(this.jobsDir, status);\n\n      try {\n        const files = await fs.readdir(statusDir);\n\n        for (const file of files) {\n          const jobPath = path.join(statusDir, file);\n          const content = await fs.readFile(jobPath, 'utf-8');\n          const job = JSON.parse(content) as Job;\n\n          if (job.completedAt) {\n            const completedTime = new Date(job.completedAt).getTime();\n\n            if (completedTime < cutoffTime) {\n              await fs.unlink(jobPath);\n              deletedCount++;\n            }\n          }\n        }\n      } catch (error) {\n        console.error(`[JobQueue] Error cleaning up ${status} jobs:`, error);\n      }\n    }\n\n    if (deletedCount > 0) {\n      console.log(`[JobQueue] Cleaned up ${deletedCount} old jobs`);\n    }\n\n    return deletedCount;\n  }\n\n  /**\n   * Get job file path\n   */\n  private getJobPath(jobId: JobId, status: JobStatus): string {\n    return path.join(this.jobsDir, status, `${jobId}.json`);\n  }\n\n  /**\n   * Get statistics about the queue\n   */\n  async getStats(): Promise<{\n    pending: number;\n    running: number;\n    complete: number;\n    failed: number;\n    cancelled: number;\n  }> {\n    const stats = {\n      pending: 0,\n      running: 0,\n      complete: 0,\n      failed: 0,\n      cancelled: 0\n    };\n\n    const statuses: JobStatus[] = ['pending', 'running', 'complete', 'failed', 'cancelled'];\n\n    for (const status of statuses) {\n      const statusDir = path.join(this.jobsDir, status);\n\n      try {\n        const files = await fs.readdir(statusDir);\n        stats[status] = files.length;\n      } catch (error) {\n        // Directory might not exist yet\n        stats[status] = 0;\n      }\n    }\n\n    return stats;\n  }\n}\n\n// Singleton instance\nlet jobQueue: JobQueue | null = null;\n\nexport function getJobQueue(): JobQueue {\n  if (!jobQueue) {\n    throw new Error('JobQueue not initialized. Call initializeJobQueue() first.');\n  }\n  return jobQueue;\n}\n\nexport async function initializeJobQueue(config: JobQueueConfig): Promise<JobQueue> {\n  jobQueue = new JobQueue(config);\n  await jobQueue.initialize();\n  return jobQueue;\n}\n","/**\n * Job Worker Base Class\n *\n * Abstract worker that polls the job queue and processes jobs.\n * Subclasses implement specific job processing logic.\n */\n\nimport type { Job } from './types';\nimport { getJobQueue } from './job-queue';\n\nexport abstract class JobWorker {\n  private running = false;\n  private currentJob: Job | null = null;\n  private pollIntervalMs: number;\n  private errorBackoffMs: number;\n\n  constructor(\n    pollIntervalMs: number = 1000,\n    errorBackoffMs: number = 5000\n  ) {\n    this.pollIntervalMs = pollIntervalMs;\n    this.errorBackoffMs = errorBackoffMs;\n  }\n\n  /**\n   * Start the worker (polls queue in loop)\n   */\n  async start(): Promise<void> {\n    this.running = true;\n    console.log(`[${this.getWorkerName()}] Started`);\n\n    while (this.running) {\n      try {\n        const job = await this.pollNextJob();\n\n        if (job) {\n          await this.processJob(job);\n        } else {\n          // No jobs available, wait before polling again\n          await this.sleep(this.pollIntervalMs);\n        }\n      } catch (error) {\n        console.error(`[${this.getWorkerName()}] Error in main loop:`, error);\n        // Back off on error to avoid tight error loops\n        await this.sleep(this.errorBackoffMs);\n      }\n    }\n\n    console.log(`[${this.getWorkerName()}] Stopped`);\n  }\n\n  /**\n   * Stop the worker (graceful shutdown)\n   */\n  async stop(): Promise<void> {\n    console.log(`[${this.getWorkerName()}] Stopping...`);\n    this.running = false;\n\n    // Wait for current job to finish (with timeout)\n    const timeout = 60000; // 60 seconds\n    const startTime = Date.now();\n\n    while (this.currentJob && (Date.now() - startTime) < timeout) {\n      await this.sleep(100);\n    }\n\n    if (this.currentJob) {\n      console.warn(`[${this.getWorkerName()}] Forced shutdown while processing job ${this.currentJob.id}`);\n    }\n  }\n\n  /**\n   * Poll for next job to process\n   */\n  private async pollNextJob(): Promise<Job | null> {\n    const jobQueue = getJobQueue();\n    const job = await jobQueue.pollNextPendingJob();\n\n    if (job && this.canProcessJob(job)) {\n      return job;\n    }\n\n    return null;\n  }\n\n  /**\n   * Process a job (handles state transitions and error handling)\n   */\n  private async processJob(job: Job): Promise<void> {\n    this.currentJob = job;\n    const jobQueue = getJobQueue();\n\n    try {\n      // Move to running state\n      const oldStatus = job.status;\n      job.status = 'running';\n      job.startedAt = new Date().toISOString();\n      await jobQueue.updateJob(job, oldStatus);\n\n      console.log(`[${this.getWorkerName()}] 🔄 Processing job ${job.id} (type: ${job.type})`);\n\n      // Execute job-specific logic\n      await this.executeJob(job);\n\n      // Move to complete state\n      job.status = 'complete';\n      job.completedAt = new Date().toISOString();\n      await jobQueue.updateJob(job, 'running');\n\n      console.log(`[${this.getWorkerName()}] ✅ Job ${job.id} completed successfully`);\n\n    } catch (error) {\n      await this.handleJobFailure(job, error);\n    } finally {\n      this.currentJob = null;\n    }\n  }\n\n  /**\n   * Handle job failure (retry or move to failed)\n   */\n  protected async handleJobFailure(job: Job, error: any): Promise<void> {\n    const jobQueue = getJobQueue();\n    job.retryCount++;\n\n    if (job.retryCount < job.maxRetries) {\n      console.log(`[${this.getWorkerName()}] Job ${job.id} failed, will retry (${job.retryCount}/${job.maxRetries})`);\n      console.log(`[${this.getWorkerName()}] Error:`, error);\n\n      // Move back to pending for retry\n      job.status = 'pending';\n      job.startedAt = undefined; // Clear start time for retry\n      await jobQueue.updateJob(job, 'running');\n\n    } else {\n      console.error(`[${this.getWorkerName()}] ❌ Job ${job.id} failed permanently after ${job.retryCount} retries`);\n      console.error(`[${this.getWorkerName()}] Error:`, error);\n\n      // Move to failed state\n      job.status = 'failed';\n      job.error = error instanceof Error ? error.message : String(error);\n      job.completedAt = new Date().toISOString();\n      await jobQueue.updateJob(job, 'running');\n    }\n  }\n\n  /**\n   * Update job progress (best-effort, doesn't throw)\n   */\n  protected async updateJobProgress(job: Job): Promise<void> {\n    try {\n      const jobQueue = getJobQueue();\n      await jobQueue.updateJob(job);\n    } catch (error) {\n      console.warn(`[${this.getWorkerName()}] Failed to update job progress:`, error);\n      // Don't throw - progress updates are best-effort\n    }\n  }\n\n  /**\n   * Sleep utility\n   */\n  protected sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n\n  // Abstract methods to be implemented by subclasses\n\n  /**\n   * Get worker name (for logging)\n   */\n  protected abstract getWorkerName(): string;\n\n  /**\n   * Check if this worker can process the given job\n   */\n  protected abstract canProcessJob(job: Job): boolean;\n\n  /**\n   * Execute the job (job-specific logic)\n   * This is where the actual work happens\n   * Throw an error to trigger retry logic\n   */\n  protected abstract executeJob(job: Job): Promise<void>;\n}\n"]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@semiont/jobs",
+  "version": "0.2.28-build.40",
+  "type": "module",
+  "description": "Filesystem-based job queue and worker infrastructure",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm run typecheck && tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@semiont/api-client": "*",
+    "@semiont/core": "*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "job-queue",
+    "worker",
+    "task-queue",
+    "filesystem",
+    "background-jobs"
+  ],
+  "author": "The AI Alliance",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/The-AI-Alliance/semiont.git",
+    "directory": "packages/jobs"
+  }
+}