claude-code-swarm 0.3.2 → 0.3.4

package/references/opentasks/src/schema/base.ts

@@ -1,88 +0,0 @@
-/**
- * Base types shared by all OpenTasks nodes
- */
-
-/**
- * Anchor for locating feedback within content
- */
-export interface Anchor {
-  /** Line number (1-indexed) */
-  line?: number;
-
-  /** Text snippet for fuzzy matching if line moves */
-  text?: string;
-
-  /** Section heading */
-  section?: string;
-
-  /** Context for relocation */
-  context_before?: string;
-  context_after?: string;
-
-  /**
-   * Anchor validity status
-   * - valid: anchor location confirmed
-   * - relocated: moved but found
-   * - stale: could not relocate
-   */
-  anchor_status?: 'valid' | 'relocated' | 'stale';
-}
-
-/**
- * Common fields shared by all node types
- */
-export interface BaseNode {
-  // === Identity ===
-  /** Hash-based ID: prefix + base36 (e.g., "s-a2b3", "i-x7k9") */
-  id: string;
-  /** UUID v4 for distributed sync */
-  uuid: string;
-
-  // === Core ===
-  /** Human-readable title */
-  title: string;
-  /** Markdown body content */
-  content?: string;
-  /** SHA256 hash of content for deduplication */
-  content_hash?: string;
-
-  // === Timestamps (ISO 8601) ===
-  created_at: string;
-  updated_at: string;
-
-  // === Organization ===
-  /** Priority: 0 (highest) to 4 (lowest) */
-  priority?: number;
-  /** Tags for categorization */
-  tags?: string[];
-  /** Parent node ID for hierarchy support */
-  parent_id?: string;
-
-  // === Context ===
-  /** OpenTasks location URI */
-  location?: string;
-  /** Git branch that created this node */
-  branch?: string;
-  /** Branches merged into this node */
-  merged_from?: string[];
-  /** Origin system: "local" | provider name */
-  source?: string;
-
-  // === Coordination ===
-  /** Agent/user ID that claimed this node */
-  claimed_by?: string;
-  /** When the node was claimed (ISO 8601) */
-  claimed_at?: string;
-  /** Soft lock expiry (ISO 8601) */
-  lock_until?: string;
-
-  // === Lifecycle ===
-  /** Soft delete flag */
-  archived?: boolean;
-  /** When archived (ISO 8601) */
-  archived_at?: string;
-
-  // === Extensibility ===
-  /** Additional metadata */
-  metadata?: Record<string, unknown>;
-}

package/references/opentasks/src/schema/edges.ts

@@ -1,78 +0,0 @@
-/**
- * Edge type definitions for OpenTasks
- *
- * Edge direction semantics: `from` → `to`
- * - "blocks": from must complete before to can start
- * - "implements": from (task) implements to (context)
- */
-
-/**
- * Core relationship types
- */
-export type CoreEdgeType =
-  | 'blocks' // from blocks to (dependency)
-  | 'implements' // task implements context
-  | 'references' // general reference
-  | 'related'; // loose association
-
-/**
- * Extended relationship types (optional, for richer semantics)
- */
-export type ExtendedEdgeType =
-  | 'parent-of' // hierarchical (alternative to parent_id)
-  | 'child-of' // inverse of parent-of
-  | 'duplicates' // marks duplicate
-  | 'supersedes' // replaces another node
-  | 'depends-on' // softer than blocks
-  | 'discovered-from'; // found while working on
-
-/**
- * Entire integration edge types (auto-created by EntireAutoLinker)
- */
-export type EntireEdgeType =
-  | 'worked-on' // task → session: "this task was worked on during this session"
-  | 'implemented-by' // task → checkpoint: "this checkpoint implements this task"
-  | 'contains'; // session → checkpoint: "this session produced this checkpoint"
-
-/**
- * Skill tracking edge types (auto-created by SkillTracker integration)
- */
-export type SkillEdgeType =
-  | 'used-skill'; // session → context node: "this session used this skill"
-
-/**
- * All edge types (extensible via string)
- */
-export type EdgeType = CoreEdgeType | ExtendedEdgeType | EntireEdgeType | SkillEdgeType | string;
-
-/**
- * Edge - Represents a relationship between nodes
- */
-export interface Edge {
-  /** Hash-based ID: "x-xxxx" */
-  id: string;
-  /** UUID v4 for distributed sync */
-  uuid: string;
-
-  /** Source node ID or external URI */
-  from_id: string;
-  /** Target node ID or external URI */
-  to_id: string;
-
-  /** Relationship type */
-  type: EdgeType;
-
-  /** When created (ISO 8601) */
-  created_at: string;
-  /** Agent/user who created this edge */
-  created_by?: string;
-
-  /** Origin system: "local" | integration name */
-  source?: string;
-
-  /** Additional metadata */
-  metadata?: Record<string, unknown>;
-
-  /** When edge was cached from provider (ISO 8601) */
-  cached_at?: string;
-}

package/references/opentasks/src/schema/index.ts

@@ -1,37 +0,0 @@
-/**
- * OpenTasks Schema - Type definitions and validation
- *
- * @packageDocumentation
- */
-
-// Base types
-export type { Anchor, BaseNode } from './base.js';
-
-// Node types
-export type { Context, Task, Feedback, ExternalNode, Node, NodeType } from './nodes.js';
-
-// Edge types
-export type { Edge, EdgeType, CoreEdgeType, ExtendedEdgeType, SkillEdgeType } from './edges.js';
-
-// Storage types
-export type {
-  StoredNode,
-  StoredEdge,
-  PersistedGraph,
-  GraphMetadata,
-  GraphChanges,
-} from './storage.js';
-
-// Validation
-export {
-  ValidationError,
-  type ValidationResult,
-  isContext,
-  isTask,
-  isFeedback,
-  isExternal,
-  validateStoredNode,
-  parseNode,
-  tryParseNode,
-  hasKnownType,
-} from './validation.js';

package/references/opentasks/src/schema/nodes.ts

@@ -1,119 +0,0 @@
-/**
- * Node type definitions for OpenTasks
- */
-
-import type { Anchor, BaseNode } from './base.js';
-
-/**
- * Context - Captures user intent, requirements, and context
- */
-export interface Context extends BaseNode {
-  type: 'context';
-
-  /**
-   * Optional status for context nodes
-   * - draft: work in progress, not ready for implementation
-   * - active: current, ready for implementation
-   * - archived: superseded or no longer relevant
-   */
-  status?: 'draft' | 'active' | 'archived' | string;
-}
-
-/**
- * Task - Actionable work item with status workflow
- */
-export interface Task extends BaseNode {
-  type: 'task';
-
-  /**
-   * Workflow status (required for tasks)
-   * - open: not started
-   * - in_progress: actively being worked on
-   * - blocked: waiting on dependency
-   * - closed: completed or won't do
-   */
-  status: 'open' | 'in_progress' | 'blocked' | 'closed' | string;
-
-  /** Who is responsible for this task */
-  assignee?: string;
-
-  /** When the task was closed (ISO 8601) */
-  closed_at?: string;
-}
-
-/**
- * Feedback - Anchored comment, suggestion, or request on a node
- */
-export interface Feedback extends BaseNode {
-  type: 'feedback';
-
-  /**
-   * What this feedback is about (required)
-   * Can be a context, task, or another feedback (for threading)
-   */
-  target_id: string;
-
-  /** Optional anchor for line/text-specific feedback */
-  target_anchor?: Anchor;
-
-  /**
-   * Type of feedback (required)
-   * - comment: general observation
-   * - suggestion: proposed change
-   * - request: action needed
-   */
-  feedback_type: 'comment' | 'suggestion' | 'request' | string;
-
-  /** Groups related feedback */
-  thread_id?: string;
-  /** Parent feedback in thread */
-  reply_to_id?: string;
-
-  /** Feedback has been addressed */
-  resolved?: boolean;
-  /** When resolved (ISO 8601) */
-  resolved_at?: string;
-  /** Feedback was dismissed (not addressed) */
-  dismissed?: boolean;
-  /** When dismissed (ISO 8601) */
-  dismissed_at?: string;
-}
-
-/**
- * ExternalNode - Reference to an entity in an external system
- * Can be phantom (just a reference) or materialized (fetched data)
- */
-export interface ExternalNode extends BaseNode {
-  type: 'external';
-
-  /** Canonical URI: "jira://PROJ-123", "beads://./bd-x7k9" */
-  uri: string;
-
-  /** Source system identifier: "jira" | "linear" | "github" | "beads" | etc. */
-  source: string;
-
-  /** Whether data has been fetched from external system */
-  materialized: boolean;
-
-  /** When data was last fetched (ISO 8601) */
-  cached_at?: string;
-
-  /** Whether cached data is known to be stale */
-  stale?: boolean;
-
-  /** Status from external system (their semantics, not ours) */
-  external_status?: string;
-
-  /** Raw data from external system */
-  external_data?: Record<string, unknown>;
-}
-
-/**
- * Discriminated union of all node types
- */
-export type Node = Context | Task | Feedback | ExternalNode;
-
-/**
- * Node type literal union
- */
-export type NodeType = 'context' | 'task' | 'feedback' | 'external';

package/references/opentasks/src/schema/storage.ts

@@ -1,130 +0,0 @@
-/**
- * Storage format types for JSONL persistence
- *
- * These types are permissive (unknown fields preserved) for:
- * - Forward compatibility with schema changes
- * - Provider data from external systems
- * - Migration safety
- */
-
-import type { Edge } from './edges.js';
-
-/**
- * Storage format for nodes (JSONL)
- * Flexible schema — all fields except core are optional
- * Unknown fields are preserved via index signature
- */
-export interface StoredNode {
-  // === CORE (required) ===
-  id: string;
-  uuid: string;
-  type: string;
-  title: string;
-  created_at: string;
-  updated_at: string;
-
-  // === COMMON (optional) ===
-  content?: string;
-  content_hash?: string;
-  priority?: number;
-  tags?: string[];
-  parent_id?: string;
-
-  // === CONTEXT (optional) ===
-  location?: string;
-  branch?: string;
-  merged_from?: string[];
-  source?: string;
-
-  // === COORDINATION (optional) ===
-  claimed_by?: string;
-  claimed_at?: string;
-  lock_until?: string;
-
-  // === LIFECYCLE (optional) ===
-  archived?: boolean;
-  archived_at?: string;
-  deleted_at?: string;
-  deleted_by?: string;
-
-  // === TASK FIELDS (optional) ===
-  status?: string;
-  assignee?: string;
-  closed_at?: string;
-
-  // === FEEDBACK FIELDS (optional) ===
-  target_id?: string;
-  target_anchor?: {
-    line?: number;
-    text?: string;
-    section?: string;
-    context_before?: string;
-    context_after?: string;
-    anchor_status?: string;
-  };
-  feedback_type?: string;
-  thread_id?: string;
-  reply_to_id?: string;
-  resolved?: boolean;
-  resolved_at?: string;
-  dismissed?: boolean;
-  dismissed_at?: string;
-
-  // === EXTERNAL FIELDS (optional) ===
-  uri?: string;
-  materialized?: boolean;
-  cached_at?: string;
-  stale?: boolean;
-  external_status?: string;
-  external_data?: Record<string, unknown>;
-
-  // === EXTENSIBILITY ===
-  metadata?: Record<string, unknown>;
-
-  /** Preserve unknown fields from external sources */
-  [key: string]: unknown;
-}
-
-/**
- * Storage format for edges (same as Edge, but aliased for clarity)
- */
-export type StoredEdge = Edge;
-
-/**
- * Complete persisted graph structure
- */
-export interface PersistedGraph {
-  nodes: StoredNode[];
-  edges: StoredEdge[];
-  metadata?: GraphMetadata;
-}
-
-/**
- * Graph-level metadata
- */
-export interface GraphMetadata {
-  /** Schema version */
-  schema_version?: {
-    major: number;
-    minor: number;
-    patch: number;
-  };
-  /** When graph was created */
-  created_at?: string;
-  /** When graph was last compacted */
-  last_compacted_at?: string;
-}
-
-/**
- * Changes to the graph (for incremental sync)
- */
-export interface GraphChanges {
-  /** Nodes that were added/modified */
-  dirtyNodes: string[];
-  /** Nodes that were deleted */
-  deletedNodes: string[];
-  /** Edges that were added/modified */
-  dirtyEdges: string[];
-  /** Edges that were deleted */
-  deletedEdges: string[];
-}

package/references/opentasks/src/schema/validation.ts

@@ -1,209 +0,0 @@
-/**
- * Type guards and validation for OpenTasks nodes
- */
-
-import type { Context, Task, Feedback, ExternalNode, Node } from './nodes.js';
-import type { StoredNode } from './storage.js';
-
-/**
- * Validation error with details
- */
-export class ValidationError extends Error {
-  constructor(
-    message: string,
-    public readonly field: string,
-    public readonly code: string,
-  ) {
-    super(message);
-    this.name = 'ValidationError';
-  }
-}
-
-/**
- * Validation result
- */
-export interface ValidationResult {
-  valid: boolean;
-  errors: Array<{
-    field: string;
-    message: string;
-    code: string;
-  }>;
-}
-
-// === Type Guards ===
-
-/**
- * Check if node is a Context
- */
-export function isContext(node: Node): node is Context {
-  return node.type === 'context';
-}
-
-/**
- * Check if node is a Task
- */
-export function isTask(node: Node): node is Task {
-  return node.type === 'task';
-}
-
-/**
- * Check if node is Feedback
- */
-export function isFeedback(node: Node): node is Feedback {
-  return node.type === 'feedback';
-}
-
-/**
- * Check if node is an ExternalNode
- */
-export function isExternal(node: Node): node is ExternalNode {
-  return node.type === 'external';
-}
-
-// === Validation ===
-
-/**
- * Validate stored node structure
- * Returns validation result with all errors
- */
-export function validateStoredNode(stored: StoredNode): ValidationResult {
-  const errors: ValidationResult['errors'] = [];
-
-  // Core validation (all types)
-  if (!stored.id) {
-    errors.push({ field: 'id', message: 'Required', code: 'REQUIRED' });
-  }
-  if (!stored.uuid) {
-    errors.push({ field: 'uuid', message: 'Required', code: 'REQUIRED' });
-  }
-  if (!stored.type) {
-    errors.push({ field: 'type', message: 'Required', code: 'REQUIRED' });
-  }
-  if (!stored.title) {
-    errors.push({ field: 'title', message: 'Required', code: 'REQUIRED' });
-  }
-  if (!stored.created_at) {
-    errors.push({ field: 'created_at', message: 'Required', code: 'REQUIRED' });
-  }
-  if (!stored.updated_at) {
-    errors.push({ field: 'updated_at', message: 'Required', code: 'REQUIRED' });
-  }
-
-  // Type-specific validation
-  switch (stored.type) {
-    case 'task':
-      if (!stored.status) {
-        errors.push({
-          field: 'status',
-          message: 'Required for tasks',
-          code: 'REQUIRED',
-        });
-      }
-      break;
-
-    case 'feedback':
-      if (!stored.target_id) {
-        errors.push({
-          field: 'target_id',
-          message: 'Required for feedback',
-          code: 'REQUIRED',
-        });
-      }
-      if (!stored.feedback_type) {
-        errors.push({
-          field: 'feedback_type',
-          message: 'Required for feedback',
-          code: 'REQUIRED',
-        });
-      }
-      break;
-
-    case 'external':
-      if (!stored.uri) {
-        errors.push({
-          field: 'uri',
-          message: 'Required for external nodes',
-          code: 'REQUIRED',
-        });
-      }
-      if (!stored.source) {
-        errors.push({
-          field: 'source',
-          message: 'Required for external nodes',
-          code: 'REQUIRED',
-        });
-      }
-      if (stored.materialized === undefined) {
-        errors.push({
-          field: 'materialized',
-          message: 'Required for external nodes',
-          code: 'REQUIRED',
-        });
-      }
-      break;
-
-    case 'context':
-      // No additional required fields
-      break;
-
-    default:
-      // Unknown type — allow but could warn
-      break;
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-/**
- * Convert StoredNode to typed Node
- * Throws ValidationError if node is invalid
- */
-export function parseNode(stored: StoredNode): Node {
-  const result = validateStoredNode(stored);
-
-  if (!result.valid) {
-    const firstError = result.errors[0];
-    throw new ValidationError(
-      `Invalid node: ${firstError.message} (${firstError.field})`,
-      firstError.field,
-      firstError.code,
-    );
-  }
-
-  // Return as the appropriate type
-  // The stored node already has all fields, we just cast based on type
-  switch (stored.type) {
-    case 'context':
-      return stored as unknown as Context;
-    case 'task':
-      return stored as unknown as Task;
-    case 'feedback':
-      return stored as unknown as Feedback;
-    case 'external':
-      return stored as unknown as ExternalNode;
-    default:
-      // For unknown types, treat as Context (most permissive)
-      return { ...stored, type: 'context' } as Context;
-  }
-}
-
-/**
- * Safely try to parse a node, returning null if invalid
- */
-export function tryParseNode(stored: StoredNode): Node | null {
-  try {
-    return parseNode(stored);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check if a stored node has a known type
- */
-export function hasKnownType(
-  stored: StoredNode,
-): stored is StoredNode & { type: 'context' | 'task' | 'feedback' | 'external' } {
-  return ['context', 'task', 'feedback', 'external'].includes(stored.type);
-}