opentasks 0.0.1 → 0.0.2

package/dist/graph/EdgeTypeRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgeTypeRegistry.d.ts","sourceRoot":"","sources":["../../src/graph/EdgeTypeRegistry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IAEb,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IAEpB,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,+CAA+C;IAC/C,YAAY,EAAE,OAAO,CAAC;IAEtB,+BAA+B;IAC/B,SAAS,EAAE,UAAU,GAAG,YAAY,CAAC;IAErC,6CAA6C;IAC7C,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IAEb,4CAA4C;IAC5C,QAAQ,EAAE,OAAO,CAAC;IAElB,wCAAwC;IACxC,SAAS,EAAE,OAAO,CAAC;IAEnB,oCAAoC;IACpC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,EA2FlD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,+BAA+B;IAC/B,UAAU,EAAE,kBAAkB,CAAC;IAE/B,uDAAuD;IACvD,WAAW,EAAE,OAAO,CAAC;IAErB,mCAAmC;IACnC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAA8C;IAC3D,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,iBAAiB,CAAgB;;IASzC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,kBAAkB,GAAG,IAAI;IAqB9C;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;IA4BjD;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIvC;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAKnC;;;;OAIG;IACH,MAAM,IAAI,kBAAkB,EAAE;IAI9B;;;;OAIG;IACH,sBAAsB,IAAI,MAAM,EAAE;IAMlC;;;;;OAKG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,EAAE;IAI3D;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAG3B;AAOD;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,CAKtD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAEzD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C"}

package/dist/graph/EdgeTypeRegistry.js

@@ -0,0 +1,255 @@
+/**
+ * Edge Type Registry for OpenTasks
+ *
+ * Makes relationship types extensible without code changes.
+ * Providers can contribute new edge types at runtime.
+ */
+/**
+ * Built-in edge types
+ */
+export const BUILTIN_EDGE_TYPES = [
+    {
+        name: 'blocks',
+        description: 'Source must complete before target can start',
+        inverseOf: 'blocked-by',
+        affectsReady: true,
+        direction: 'directed',
+        providers: ['native', 'beads'],
+    },
+    {
+        name: 'blocked-by',
+        description: 'Target is blocked by source (inverse of blocks)',
+        inverseOf: 'blocks',
+        affectsReady: true,
+        direction: 'directed',
+        providers: ['native', 'beads'],
+    },
+    {
+        name: 'implements',
+        description: 'Task implements a context',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native'],
+    },
+    {
+        name: 'parent-of',
+        description: 'Hierarchical parent relationship',
+        inverseOf: 'child-of',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native', 'beads'],
+    },
+    {
+        name: 'child-of',
+        description: 'Hierarchical child relationship (inverse of parent-of)',
+        inverseOf: 'parent-of',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native', 'beads'],
+    },
+    {
+        name: 'discovered-from',
+        description: 'Found while working on another node',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native', 'beads'],
+    },
+    {
+        name: 'related',
+        description: 'Loosely associated nodes',
+        affectsReady: false,
+        direction: 'undirected',
+        providers: ['native', 'beads'],
+    },
+    {
+        name: 'references',
+        description: 'General reference link',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native'],
+    },
+    {
+        name: 'depends-on',
+        description: 'Softer dependency than blocks',
+        inverseOf: 'dependency-of',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native', 'beads'],
+    },
+    {
+        name: 'dependency-of',
+        description: 'Inverse of depends-on',
+        inverseOf: 'depends-on',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native', 'beads'],
+    },
+    {
+        name: 'duplicates',
+        description: 'Marks a duplicate of another node',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native'],
+    },
+    {
+        name: 'supersedes',
+        description: 'Replaces another node',
+        affectsReady: false,
+        direction: 'directed',
+        providers: ['native'],
+    },
+];
+/**
+ * Edge Type Registry
+ *
+ * Manages registered edge types and provides lookup functionality.
+ * Supports inverse relationships (e.g., blocks ↔ blocked-by).
+ */
+export class EdgeTypeRegistry {
+    types = new Map();
+    inverses = new Map();
+    registrationOrder = [];
+    constructor() {
+        // Register built-in types
+        for (const type of BUILTIN_EDGE_TYPES) {
+            this.register(type);
+        }
+    }
+    /**
+     * Register a new edge type
+     *
+     * @param definition - The edge type definition
+     * @throws Error if type already registered with different definition
+     */
+    register(definition) {
+        const existing = this.types.get(definition.name);
+        if (existing) {
+            // Allow re-registration with same definition (idempotent)
+            if (JSON.stringify(existing) !== JSON.stringify(definition)) {
+                throw new Error(`Edge type '${definition.name}' already registered with different definition`);
+            }
+            return;
+        }
+        this.types.set(definition.name, definition);
+        this.registrationOrder.push(definition.name);
+        // Track inverse relationships
+        if (definition.inverseOf) {
+            this.inverses.set(definition.name, definition.inverseOf);
+        }
+    }
+    /**
+     * Look up an edge type by name
+     *
+     * @param name - The edge type name
+     * @returns The lookup result or null if not found
+     */
+    lookup(name) {
+        const definition = this.types.get(name);
+        if (!definition) {
+            return null;
+        }
+        // Check if this is an inverse type
+        const inverse = definition.inverseOf;
+        if (inverse && this.types.has(inverse)) {
+            // The canonical form is the one registered first
+            const nameIndex = this.registrationOrder.indexOf(name);
+            const inverseIndex = this.registrationOrder.indexOf(inverse);
+            const isCanonical = nameIndex < inverseIndex;
+            return {
+                definition,
+                isCanonical,
+                canonicalType: isCanonical ? name : inverse,
+            };
+        }
+        return {
+            definition,
+            isCanonical: true,
+            canonicalType: name,
+        };
+    }
+    /**
+     * Get the inverse of an edge type
+     *
+     * @param name - The edge type name
+     * @returns The inverse type name or null if none
+     */
+    getInverse(name) {
+        return this.inverses.get(name) ?? null;
+    }
+    /**
+     * Check if an edge type affects ready status
+     *
+     * @param name - The edge type name
+     * @returns True if this edge type affects ready status
+     */
+    affectsReady(name) {
+        const definition = this.types.get(name);
+        return definition?.affectsReady ?? false;
+    }
+    /**
+     * Get all registered edge types
+     *
+     * @returns Array of all edge type definitions
+     */
+    getAll() {
+        return Array.from(this.types.values());
+    }
+    /**
+     * Get edge types that affect ready status
+     *
+     * @returns Array of edge type names that affect ready
+     */
+    getReadyAffectingTypes() {
+        return this.getAll()
+            .filter((t) => t.affectsReady)
+            .map((t) => t.name);
+    }
+    /**
+     * Get edge types supported by a provider
+     *
+     * @param provider - The provider name
+     * @returns Array of edge type definitions
+     */
+    getTypesForProvider(provider) {
+        return this.getAll().filter((t) => t.providers.includes(provider));
+    }
+    /**
+     * Check if a type is registered
+     *
+     * @param name - The edge type name
+     * @returns True if the type is registered
+     */
+    has(name) {
+        return this.types.has(name);
+    }
+}
+/**
+ * Singleton instance of the edge type registry
+ */
+let globalRegistry = null;
+/**
+ * Get the global edge type registry instance
+ *
+ * @returns The singleton EdgeTypeRegistry
+ */
+export function getEdgeTypeRegistry() {
+    if (!globalRegistry) {
+        globalRegistry = new EdgeTypeRegistry();
+    }
+    return globalRegistry;
+}
+/**
+ * Create a new edge type registry (for testing)
+ *
+ * @returns A fresh EdgeTypeRegistry instance
+ */
+export function createEdgeTypeRegistry() {
+    return new EdgeTypeRegistry();
+}
+/**
+ * Reset the global registry (for testing)
+ */
+export function resetEdgeTypeRegistry() {
+    globalRegistry = null;
+}
+//# sourceMappingURL=EdgeTypeRegistry.js.map

package/dist/graph/EdgeTypeRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgeTypeRegistry.js","sourceRoot":"","sources":["../../src/graph/EdgeTypeRegistry.ts"],"names":[],"mappings":"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"}

package/dist/graph/FederatedGraph.d.ts

@@ -0,0 +1,296 @@
+/**
+ * Federated Graph for OpenTasks
+ *
+ * Provides unified traversal API over the in-memory Graphology graph.
+ * Supports queries across providers with lazy hydration (hydration handled separately).
+ */
+import type { GraphologyAdapter, NodeURI, GraphNodeAttributes } from './GraphologyAdapter.js';
+import type { EdgeTypeDefinition } from './EdgeTypeRegistry.js';
+/**
+ * Direction for edge traversal
+ */
+export type TraversalDirection = 'in' | 'out' | 'both';
+/**
+ * Options for related() query
+ */
+export interface RelatedOptions {
+    /** Edge type to filter by */
+    edgeType?: string | string[];
+    /** Direction of edges to follow */
+    direction?: TraversalDirection;
+}
+/**
+ * Options for reachable() query
+ */
+export interface ReachableOptions {
+    /** Edge type(s) to follow */
+    edgeType?: string | string[];
+    /** Direction of edges to follow */
+    direction?: TraversalDirection;
+    /** Maximum traversal depth (default: Infinity) */
+    maxDepth?: number;
+}
+/**
+ * Options for shortestPath() query
+ */
+export interface ShortestPathOptions {
+    /** Edge types to consider (default: all) */
+    edgeTypes?: string[];
+}
+/**
+ * Predicate function for filtering nodes during traversal
+ */
+export type NodePredicate = (uri: NodeURI, attrs: GraphNodeAttributes | null) => boolean;
+/**
+ * A single step in a traversal pattern
+ */
+export interface EdgeStep {
+    /** Edge type to follow */
+    type: string;
+    /** Direction to traverse */
+    direction: TraversalDirection;
+    /** Minimum number of hops (default: 1) */
+    minHops?: number;
+    /** Maximum number of hops (default: 1, use Infinity for transitive) */
+    maxHops?: number;
+}
+/**
+ * Pattern for multi-step graph traversal
+ */
+export interface TraversalPattern {
+    /** Sequence of edge steps to follow */
+    steps: EdgeStep[];
+    /** Maximum total results to return */
+    limit?: number;
+    /** Filter predicate applied to each node before yielding */
+    filter?: NodePredicate;
+}
+/**
+ * Result from a traversal step
+ */
+export interface TraversalResult {
+    /** The node URI reached */
+    uri: NodeURI;
+    /** Total depth from start (sum of all steps) */
+    depth: number;
+    /** Full path from start to this node */
+    path: NodeURI[];
+    /** The step index that led to this result */
+    stepIndex: number;
+    /** The edge type that led here */
+    edgeType: string;
+}
+/**
+ * Selector type for convenience syntax
+ *
+ * - `+uri` - Children (direct outgoing edges)
+ * - `uri+` - Descendants (transitive outgoing edges)
+ * - `@uri` - Neighbors (all directly connected nodes)
+ */
+export type SelectorType = 'children' | 'descendants' | 'neighbors' | 'literal';
+/**
+ * Parsed selector result
+ */
+export interface ParsedSelector {
+    /** The type of selector */
+    type: SelectorType;
+    /** The base URI (without selector prefix/suffix) */
+    uri: NodeURI;
+    /** Original selector string */
+    original: string;
+}
+/**
+ * Graph capabilities summary
+ */
+export interface GraphCapabilities {
+    /** All supported edge types */
+    edgeTypes: EdgeTypeDefinition[];
+    /** Edge types that affect ready status */
+    readyAffectingTypes: string[];
+    /** Provider-specific capabilities */
+    providers: Map<string, EdgeTypeDefinition[]>;
+}
+/**
+ * Federated Graph Interface
+ *
+ * Provides unified traversal API over multiple providers.
+ */
+export interface FederatedGraph {
+    /** The underlying Graphology adapter */
+    readonly adapter: GraphologyAdapter;
+    /**
+     * Get directly related nodes (single hop)
+     *
+     * @param uri - Starting node URI
+     * @param options - Query options (edgeType, direction)
+     * @returns Array of neighboring node URIs
+     */
+    related(uri: NodeURI, options?: RelatedOptions): NodeURI[];
+    /**
+     * Get transitively reachable nodes (multi-hop)
+     *
+     * @param uri - Starting node URI
+     * @param options - Query options (edgeType, direction, maxDepth)
+     * @returns Array of reachable node URIs (not including start)
+     */
+    reachable(uri: NodeURI, options?: ReachableOptions): NodeURI[];
+    /**
+     * Find shortest path between two nodes
+     *
+     * @param from - Starting node URI
+     * @param to - Target node URI
+     * @param options - Query options (edgeTypes)
+     * @returns Array of node URIs forming the path, or null if no path exists
+     */
+    shortestPath(from: NodeURI, to: NodeURI, options?: ShortestPathOptions): NodeURI[] | null;
+    /**
+     * Check if a path exists between two nodes
+     *
+     * @param from - Starting node URI
+     * @param to - Target node URI
+     * @param options - Query options (edgeTypes)
+     * @returns True if a path exists
+     */
+    hasPath(from: NodeURI, to: NodeURI, options?: ShortestPathOptions): boolean;
+    /**
+     * Get node data by URI
+     *
+     * @param uri - Node URI
+     * @returns Node attributes or null if not found
+     */
+    getNode(uri: NodeURI): GraphNodeAttributes | null;
+    /**
+     * Check if a node exists in the graph
+     *
+     * @param uri - Node URI
+     * @returns True if the node exists
+     */
+    hasNode(uri: NodeURI): boolean;
+    /**
+     * Get all nodes in the graph
+     *
+     * @returns Array of all node URIs
+     */
+    nodes(): NodeURI[];
+    /**
+     * Get graph statistics
+     */
+    stats(): {
+        nodes: number;
+        edges: number;
+    };
+    /**
+     * Advanced traversal with multi-step patterns
+     *
+     * Enables complex queries like "find all specs → implementing issues → their blockers"
+     * Uses async iteration for lazy evaluation.
+     *
+     * @param startUris - Starting node URI(s)
+     * @param pattern - Traversal pattern with steps
+     * @returns Async iterable of traversal results
+     *
+     * @example
+     * ```typescript
+     * // Find all issues that implement specs, then their transitive blockers
+     * const pattern = {
+     *   steps: [
+     *     { type: 'implements', direction: 'in' },
+     *     { type: 'blocks', direction: 'in', maxHops: Infinity }
+     *   ]
+     * }
+     * for await (const result of graph.traverse(['native://s-abc'], pattern)) {
+     *   console.log(result.uri, result.depth, result.path)
+     * }
+     * ```
+     */
+    traverse(startUris: NodeURI | NodeURI[], pattern: TraversalPattern): AsyncIterable<TraversalResult>;
+    /**
+     * Parse a selector string into its components
+     *
+     * Supports:
+     * - `+uri` - Children (direct outgoing neighbors)
+     * - `uri+` - Descendants (transitive outgoing, infinite depth)
+     * - `@uri` - Neighbors (all directly connected nodes, both directions)
+     * - `uri` - Literal URI (no expansion)
+     *
+     * @param selector - The selector string to parse
+     * @returns Parsed selector with type and base URI
+     *
+     * @example
+     * ```typescript
+     * graph.parseSelector('+native://s-abc')  // { type: 'children', uri: 'native://s-abc' }
+     * graph.parseSelector('native://s-abc+')  // { type: 'descendants', uri: 'native://s-abc' }
+     * graph.parseSelector('@native://i-123')  // { type: 'neighbors', uri: 'native://i-123' }
+     * graph.parseSelector('native://i-123')   // { type: 'literal', uri: 'native://i-123' }
+     * ```
+     */
+    parseSelector(selector: string): ParsedSelector;
+    /**
+     * Expand a selector into node URIs
+     *
+     * @param selector - Selector string (with +, @, etc.) or plain URI
+     * @param options - Optional edge type filter for expansion
+     * @returns Array of matching node URIs
+     *
+     * @example
+     * ```typescript
+     * // Get all children of a spec
+     * graph.expandSelector('+native://s-abc')
+     *
+     * // Get all descendants following 'implements' edges
+     * graph.expandSelector('native://s-abc+', { edgeType: 'implements' })
+     *
+     * // Get all neighbors
+     * graph.expandSelector('@native://i-123')
+     * ```
+     */
+    expandSelector(selector: string, options?: RelatedOptions): NodeURI[];
+    /**
+     * Get all registered edge types
+     *
+     * @returns Array of edge type definitions
+     */
+    edgeTypes(): EdgeTypeDefinition[];
+    /**
+     * Get graph capabilities including supported edge types per provider
+     *
+     * @returns Capabilities summary
+     */
+    capabilities(): GraphCapabilities;
+}
+/**
+ * Implementation of FederatedGraph
+ */
+export declare class FederatedGraphImpl implements FederatedGraph {
+    readonly adapter: GraphologyAdapter;
+    constructor(adapter: GraphologyAdapter);
+    related(uri: NodeURI, options?: RelatedOptions): NodeURI[];
+    reachable(uri: NodeURI, options?: ReachableOptions): NodeURI[];
+    shortestPath(from: NodeURI, to: NodeURI, options?: ShortestPathOptions): NodeURI[] | null;
+    /**
+     * BFS-based shortest path with edge type filtering
+     */
+    private bfsShortestPath;
+    hasPath(from: NodeURI, to: NodeURI, options?: ShortestPathOptions): boolean;
+    getNode(uri: NodeURI): GraphNodeAttributes | null;
+    hasNode(uri: NodeURI): boolean;
+    nodes(): NodeURI[];
+    stats(): {
+        nodes: number;
+        edges: number;
+    };
+    traverse(startUris: NodeURI | NodeURI[], pattern: TraversalPattern): AsyncIterable<TraversalResult>;
+    parseSelector(selector: string): ParsedSelector;
+    expandSelector(selector: string, options?: RelatedOptions): NodeURI[];
+    edgeTypes(): EdgeTypeDefinition[];
+    capabilities(): GraphCapabilities;
+    private getNeighbors;
+}
+/**
+ * Create a FederatedGraph instance
+ *
+ * @param adapter - The GraphologyAdapter to use
+ * @returns A FederatedGraph instance
+ */
+export declare function createFederatedGraph(adapter: GraphologyAdapter): FederatedGraph;
+//# sourceMappingURL=FederatedGraph.d.ts.map

package/dist/graph/FederatedGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FederatedGraph.d.ts","sourceRoot":"","sources":["../../src/graph/FederatedGraph.ts"],"names":[],"mappings":"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"}