@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/intent-guard.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { CLI_NAME } from '../branding.js';
+const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
+const changeIntentPattern = /\b(add|alter|apply|build|change|code|commit|create|delete|edit|execute|fix|generate|implement|install|move|refactor|remove|rename|resolve|run|scaffold|update|write|ajust|altere|aplique|corrija|crie|edite|execute|faca|faça|gere|implemente|mova|remova|renomeie|resolva|rode|atualize)\b/i;
+const readOnlyPattern = /\b(read-only|readonly|no edit|no edits|sem editar|somente leitura|apenas leia|apenas leitura|explique|explique-me|analise|review|status|estado atual|listar|list|show|mostrar)\b/i;
+const outsideSddPattern = /\b(skip codesdd|sem codesdd|fora do codesdd|outside codesdd|do not use codesdd|nao use codesdd|não use codesdd)\b/i;
+export const sddIntentGuardInputSchema = z.object({
+    request: z.string().min(1),
+    featureRef: z.string().regex(FEATURE_REF_PATTERN).optional(),
+});
+export const sddIntentGuardResultSchema = z.object({
+    request: z.string(),
+    classification: z.enum(['change_request', 'read_only', 'outside_codesdd']),
+    requires_codesdd_planning: z.boolean(),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN).optional(),
+    reason: z.string(),
+    required_commands: z.array(z.string()),
+    warnings: z.array(z.string()),
+});
+export function evaluateSddIntentGuard(input) {
+    const parsed = sddIntentGuardInputSchema.parse(input);
+    const request = parsed.request.trim();
+    const explicitlyOutside = outsideSddPattern.test(request);
+    const readOnly = readOnlyPattern.test(request) && !changeIntentPattern.test(request);
+    const changeRequest = changeIntentPattern.test(request) && !explicitlyOutside;
+    if (explicitlyOutside) {
+        return sddIntentGuardResultSchema.parse({
+            request,
+            classification: 'outside_codesdd',
+            requires_codesdd_planning: false,
+            feature_ref: parsed.featureRef,
+            reason: 'The request explicitly opts out of CodeSDD handling.',
+            required_commands: [],
+            warnings: ['Only honor this opt-out when it does not conflict with repository governance policy.'],
+        });
+    }
+    if (!changeRequest || readOnly) {
+        return sddIntentGuardResultSchema.parse({
+            request,
+            classification: 'read_only',
+            requires_codesdd_planning: false,
+            feature_ref: parsed.featureRef,
+            reason: 'The request is read-only and does not imply implementation, edits, validation, execution, or finalize.',
+            required_commands: [],
+            warnings: [],
+        });
+    }
+    const featureCommand = parsed.featureRef
+        ? `${CLI_NAME} sdd context ${parsed.featureRef}`
+        : `${CLI_NAME} sdd context <FEAT-ID>`;
+    return sddIntentGuardResultSchema.parse({
+        request,
+        classification: 'change_request',
+        requires_codesdd_planning: true,
+        feature_ref: parsed.featureRef,
+        reason: 'The request implies implementation, edits, validation, execution, or finalize in an initialized CodeSDD repository.',
+        required_commands: [
+            `${CLI_NAME} sdd onboard system`,
+            `${CLI_NAME} sdd next`,
+            featureCommand,
+        ],
+        warnings: parsed.featureRef
+            ? []
+            : ['Bind this request to the active or ready FEAT returned by CodeSDD before coding.'],
+    });
+}
+//# sourceMappingURL=intent-guard.js.map

package/dist/core/sdd/json-schema.js

@@ -1,34 +1,50 @@
 import { toJSONSchema } from 'zod';
 import { workspaceChangelogSchema, workspacePlanSchema, workspaceQualitySchema, workspaceSpecSchema, workspaceTasksSchema, } from './workspace-schemas.js';
+import { buildPluginManifestJsonSchema } from './plugin-manifest.js';
+import { pluginRegistryStateSchema } from './plugin-registry.js';
+import { pluginArtifactManifestSchema, pluginDryRunExecutionPlanSchema, pluginRollbackManifestSchema, pluginRuntimeInvocationPlanSchema, } from './plugin-broker.js';
+import { pluginPolicyEvaluationSchema } from './plugin-policy.js';
+import { pluginPolicyPackEvaluationSchema, pluginPolicyPackSchema } from './plugin-policy-pack.js';
+import { pluginComplianceIndexSchema, pluginEvidenceManifestSchema, pluginValidationManifestSchema, } from './plugin-evidence.js';
+import { buildPluginSdkJsonSchemas } from './plugin-sdk-contract.js';
+import { pluginSkillBindingResolutionSchema, pluginSkillBindingSchema, } from './plugin-skill-binding.js';
+import { agentBindingAdapterSchema, agentBindingResolutionSchema, } from './agent-binding.js';
+import { buildAgentRuntimeJsonSchemas } from './agent-runtime-contract.js';
+import { parallelFeatAutomationPlanSchema, parallelFeatAutomationRequestSchema, parallelFeatSchedulerRequestSchema, parallelFeatSchedulerResultSchema, } from './parallel-feat-automation.js';
+import { backlogProjectionPlanSchema, backlogProviderContractSchema, } from './backlog-provider-contract.js';
+import { qualityArchitectureSchema, qualityEvidenceBundleSchema, qualityRunSchema, qualityScenarioSchema, } from './quality-validation.js';
+import { buildSdkAgentPluginQualityGateJsonSchemas } from './sdk-agent-plugin-quality-gates.js';
+import { deepagentDecisionEvidenceSchema, deepagentEnvContractSchema, deepagentQualityEvidenceSchema, deepagentRunEvidenceSchema, deepagentRunPlanSchema, deepagentRunRequestSchema, deepagentSubagentEvidenceSchema, deepagentToolCallEvidenceSchema, } from './deepagent-contracts.js';
+import { adrFrontmatterSchema, debateFrontmatterSchema, discardedFrontmatterSchema, epicFrontmatterSchema, insightFrontmatterSchema, } from './governance-schemas.js';
 const JSON_SCHEMA_DRAFT = 'https://json-schema.org/draft/2020-12/schema';
 const WORKSPACE_JSON_SCHEMA_DESCRIPTORS = [
     {
         fileName: '1-spec.yaml',
-        title: 'OpenSDD Workspace Spec',
+        title: 'CodeSDD Workspace Spec',
         description: 'Machine-readable contract for the active/planned/archived FEAT spec workspace document.',
         schema: workspaceSpecSchema,
     },
     {
         fileName: '2-plan.yaml',
-        title: 'OpenSDD Workspace Plan',
+        title: 'CodeSDD Workspace Plan',
         description: 'Machine-readable contract for the FEAT execution plan workspace document.',
         schema: workspacePlanSchema,
     },
     {
         fileName: '3-tasks.yaml',
-        title: 'OpenSDD Workspace Tasks',
+        title: 'CodeSDD Workspace Tasks',
         description: 'Machine-readable contract for the phased FEAT task roadmap workspace document.',
         schema: workspaceTasksSchema,
     },
     {
         fileName: '4-changelog.yaml',
-        title: 'OpenSDD Workspace Changelog',
+        title: 'CodeSDD Workspace Changelog',
         description: 'Machine-readable contract for the FEAT execution changelog workspace document.',
         schema: workspaceChangelogSchema,
     },
     {
         fileName: '5-quality.yaml',
-        title: 'OpenSDD Workspace Quality',
+        title: 'CodeSDD Workspace Quality',
         description: 'Machine-readable contract for the FEAT quality evidence and remediation workspace document.',
         schema: workspaceQualitySchema,
     },
@@ -51,9 +67,95 @@ export function buildWorkspaceJsonSchemaCatalog() {
     return {
         $schema: JSON_SCHEMA_DRAFT,
         schema_version: 1,
-        contract: 'opensdd-workspace-documents',
+        contract: 'codesdd-workspace-documents',
         generated_from: 'src/core/sdd/workspace-schemas.ts',
         documents: buildWorkspaceJsonSchemas(),
+        plugin_manifests: {
+            'codesdd-plugin.yaml': buildPluginManifestJsonSchema(),
+        },
+        plugin_sdk_contracts: buildPluginSdkJsonSchemas(),
+        plugin_registries: {
+            'plugin-registry.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginRegistryStateSchema), 'CodeSDD Plugin Registry State', 'Machine-readable state contract for registered CodeSDD enterprise plugins.'),
+        },
+        plugin_broker_plans: {
+            'plugin-dry-run-plan.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginDryRunExecutionPlanSchema), 'CodeSDD Plugin Dry-Run Execution Plan', 'Machine-readable dry-run broker plan contract for a resolved CodeSDD enterprise plugin capability.'),
+        },
+        plugin_policy_evaluations: {
+            'plugin-policy-evaluation.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginPolicyEvaluationSchema), 'CodeSDD Plugin Policy Evaluation', 'Machine-readable trust policy evaluation result for a CodeSDD enterprise plugin request.'),
+        },
+        plugin_runtime_invocations: {
+            'plugin-runtime-invocation-plan.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginRuntimeInvocationPlanSchema), 'CodeSDD Plugin Runtime Invocation Plan', 'Machine-readable runtime invocation envelope and authorization plan for a CodeSDD enterprise plugin capability.'),
+        },
+        plugin_artifact_manifests: {
+            'plugin-artifact-manifest.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginArtifactManifestSchema), 'CodeSDD Plugin Artifact Manifest', 'Machine-readable artifact output contract for a CodeSDD enterprise plugin invocation.'),
+        },
+        plugin_rollback_manifests: {
+            'plugin-rollback-manifest.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginRollbackManifestSchema), 'CodeSDD Plugin Rollback Manifest', 'Machine-readable rollback evidence contract for a CodeSDD enterprise plugin invocation.'),
+        },
+        plugin_policy_packs: {
+            'plugin-policy-pack.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginPolicyPackSchema), 'CodeSDD Plugin Policy Pack', 'Machine-readable enterprise policy pack contract for plugin supply-chain, dependency, security, and execution governance.'),
+        },
+        plugin_policy_pack_evaluations: {
+            'plugin-policy-pack-evaluation.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginPolicyPackEvaluationSchema), 'CodeSDD Plugin Policy Pack Evaluation', 'Machine-readable policy pack evaluation result for a CodeSDD enterprise plugin manifest.'),
+        },
+        plugin_evidence_manifests: {
+            'plugin-evidence-manifest.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginEvidenceManifestSchema), 'CodeSDD Plugin Evidence Manifest', 'Machine-readable evidence manifest contract for a CodeSDD enterprise plugin operation.'),
+        },
+        plugin_validation_manifests: {
+            'plugin-validation-manifest.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginValidationManifestSchema), 'CodeSDD Plugin Validation Manifest', 'Machine-readable validation evidence contract for a CodeSDD enterprise plugin operation.'),
+        },
+        plugin_compliance_indexes: {
+            'plugin-compliance-index.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginComplianceIndexSchema), 'CodeSDD Plugin Compliance Index', 'Machine-readable compliance score and criterion index for a CodeSDD enterprise plugin operation.'),
+        },
+        plugin_skill_bindings: {
+            'plugin-skill-binding.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginSkillBindingSchema), 'CodeSDD Plugin Skill Binding', 'Machine-readable mapping from an SDD skill to compatible CodeSDD enterprise plugin capabilities.'),
+        },
+        plugin_skill_binding_resolutions: {
+            'plugin-skill-binding-resolution.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginSkillBindingResolutionSchema), 'CodeSDD Plugin Skill Binding Resolution', 'Machine-readable resolution result for a FEAT recommended skill, plugin binding, and requested capability.'),
+        },
+        agent_binding_adapters: {
+            'agent-binding-adapter.yaml': normalizeJsonSchemaDocument(toJSONSchema(agentBindingAdapterSchema), 'CodeSDD Agent Binding Adapter', 'Machine-readable provider adapter contract for Codex, OpenCode, Claude Code, CloudCode, and test agent bindings.'),
+        },
+        agent_binding_resolutions: {
+            'agent-binding-resolution.yaml': normalizeJsonSchemaDocument(toJSONSchema(agentBindingResolutionSchema), 'CodeSDD Agent Binding Resolution', 'Machine-readable resolution result for selecting a compatible coding-agent adapter for a FEAT task.'),
+        },
+        agent_runtime_contracts: buildAgentRuntimeJsonSchemas(),
+        parallel_feat_automation: {
+            'parallel-feat-automation-request.yaml': normalizeJsonSchemaDocument(toJSONSchema(parallelFeatAutomationRequestSchema), 'CodeSDD Parallel FEAT Automation Request', 'Machine-readable input contract for planning safe parallel FEAT execution waves.'),
+            'parallel-feat-automation-plan.yaml': normalizeJsonSchemaDocument(toJSONSchema(parallelFeatAutomationPlanSchema), 'CodeSDD Parallel FEAT Automation Plan', 'Machine-readable execution plan for safe parallel FEAT waves, quality gates, and commit boundaries.'),
+            'parallel-feat-scheduler-request.yaml': normalizeJsonSchemaDocument(toJSONSchema(parallelFeatSchedulerRequestSchema), 'CodeSDD Parallel FEAT Scheduler Request', 'Machine-readable input contract for dependency-aware chained FEAT wave scheduling.'),
+            'parallel-feat-scheduler-result.yaml': normalizeJsonSchemaDocument(toJSONSchema(parallelFeatSchedulerResultSchema), 'CodeSDD Parallel FEAT Scheduler Result', 'Machine-readable scheduler result linking chained FEAT waves, blocked dependencies, and the execution plan.'),
+        },
+        backlog_integrations: {
+            'backlog-provider-contract.yaml': normalizeJsonSchemaDocument(toJSONSchema(backlogProviderContractSchema), 'CodeSDD Backlog Provider Contract', 'Machine-readable provider contract for projecting canonical CodeSDD backlog state to external planning tools.'),
+            'backlog-projection-plan.yaml': normalizeJsonSchemaDocument(toJSONSchema(backlogProjectionPlanSchema), 'CodeSDD Backlog Projection Plan', 'Machine-readable dry-run or apply projection plan for external backlog/task-management providers.'),
+        },
+        quality_validation: {
+            'quality-scenario.yaml': normalizeJsonSchemaDocument(toJSONSchema(qualityScenarioSchema), 'CodeSDD Quality Scenario', 'Machine-readable golden scenario contract for enterprise CodeSDD quality validation runs.'),
+            'quality-run.yaml': normalizeJsonSchemaDocument(toJSONSchema(qualityRunSchema), 'CodeSDD Quality Run', 'Machine-readable execution record for a CodeSDD quality validation scenario.'),
+            'quality-architecture-schema.yaml': normalizeJsonSchemaDocument(toJSONSchema(qualityArchitectureSchema), 'CodeSDD Quality Architecture Schema', 'Machine-readable architecture gateway contract for generated product validation.'),
+            'quality-evidence-bundle.yaml': normalizeJsonSchemaDocument(toJSONSchema(qualityEvidenceBundleSchema), 'CodeSDD Quality Evidence Bundle', 'Machine-readable evidence bundle contract tying scenario, run, artifacts, checksums, findings, and exceptions together.'),
+            ...buildSdkAgentPluginQualityGateJsonSchemas(),
+        },
+        deepagent_execution: {
+            'deepagent-run-request.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentRunRequestSchema), 'CodeSDD DeepAgent Run Request', 'Machine-readable request contract for governed DeepAgents execution with scoped tools, write policy, env contract, and expected evidence.'),
+            'deepagent-run-plan.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentRunPlanSchema), 'CodeSDD DeepAgent Run Plan', 'Machine-readable tactical plan contract for DeepAgents runs with subagent routing, approvals, validation matrix, and residual risks.'),
+            'deepagent-run-evidence.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentRunEvidenceSchema), 'CodeSDD DeepAgent Run Evidence', 'Machine-readable evidence contract for DeepAgents run execution status, artifacts, validations, decisions, and finalize intent.'),
+            'deepagent-subagent-evidence.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentSubagentEvidenceSchema), 'CodeSDD DeepAgent Subagent Evidence', 'Machine-readable subagent execution evidence contract with prompt purpose, tools, skills, structured output, confidence, and risks.'),
+            'deepagent-tool-call-evidence.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentToolCallEvidenceSchema), 'CodeSDD DeepAgent Tool Call Evidence', 'Machine-readable tool call evidence contract with policy gates, HITL decisions, state access class, and execution results.'),
+            'deepagent-quality-evidence.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentQualityEvidenceSchema), 'CodeSDD DeepAgent Quality Evidence', 'Machine-readable requirement-to-validation evidence matrix contract for DeepAgents runs, including residual risk traceability.'),
+            'deepagent-decision-evidence.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentDecisionEvidenceSchema), 'CodeSDD DeepAgent Decision Evidence', 'Machine-readable decision trace contract for DeepAgents runs, including alternatives, approvals, ADR requirement, and rationale.'),
+            'deepagent-env-contract.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentEnvContractSchema), 'CodeSDD DeepAgent Environment Contract', 'Machine-readable execution environment contract for DeepAgents runs, including env allowlist, secrets references, pass-through rules, and blocked paths.'),
+        },
+        governance_discovery: {
+            'insight.yaml': normalizeJsonSchemaDocument(toJSONSchema(insightFrontmatterSchema), 'CodeSDD Insight Frontmatter', 'Machine-readable frontmatter contract for INS governance artifacts with Markdown body compatibility.'),
+            'debate.yaml': normalizeJsonSchemaDocument(toJSONSchema(debateFrontmatterSchema), 'CodeSDD Debate Frontmatter', 'Machine-readable frontmatter contract for DEB governance artifacts with Markdown body compatibility.'),
+            'epic.yaml': normalizeJsonSchemaDocument(toJSONSchema(epicFrontmatterSchema), 'CodeSDD Epic Frontmatter', 'Machine-readable frontmatter contract for EPIC governance artifacts with Markdown body compatibility.'),
+            'discarded.yaml': normalizeJsonSchemaDocument(toJSONSchema(discardedFrontmatterSchema), 'CodeSDD Discarded Frontmatter', 'Machine-readable frontmatter contract for discarded governance artifacts with Markdown body compatibility.'),
+        },
+        governance_decisions: {
+            'adr.yaml': normalizeJsonSchemaDocument(toJSONSchema(adrFrontmatterSchema), 'CodeSDD ADR Frontmatter', 'Machine-readable frontmatter contract for ADR governance artifacts with Markdown body compatibility.'),
+        },
     };
 }
 //# sourceMappingURL=json-schema.js.map

package/dist/core/sdd/knowledge-graph.d.ts

@@ -0,0 +1,45 @@
+export type GraphDirection = 'outbound' | 'inbound' | 'both';
+export interface DuckDbExecutor {
+    run(sql: string, params?: readonly unknown[]): Promise<void>;
+    all<T>(sql: string, params?: readonly unknown[]): Promise<T[]>;
+    close(): Promise<void>;
+}
+export interface TreeSitterSymbolIndexRecord {
+    id?: string;
+    kind: string;
+    name: string;
+    startLine: number;
+    endLine: number;
+    parentId?: string;
+    references?: string[];
+    signature?: string;
+}
+export interface TreeSitterFileIndexPayload {
+    filePath: string;
+    language: string;
+    symbols: TreeSitterSymbolIndexRecord[];
+}
+export interface GraphTraversalRow {
+    depth: number;
+    source_id: string;
+    target_id: string;
+    relation: string;
+}
+export type DuckDbDatabase = {
+    run(sql: string, params: unknown[], cb: (error: Error | null) => void): void;
+    all(sql: string, params: unknown[], cb: (error: Error | null, rows?: Array<Record<string, unknown>>) => void): void;
+    close?: (cb: (error: Error | null) => void) => void;
+};
+export declare function resolveDuckDbConstructor(mod: unknown): new (databasePath: string) => DuckDbDatabase;
+export declare function createDuckDbExecutor(databasePath: string): Promise<DuckDbExecutor>;
+export declare function normalizeGraphPath(value: string): string;
+export declare function hashSymbolId(filePath: string, symbolKey: string): string;
+export declare function traversalSql(direction: Exclude<GraphDirection, 'both'>): string;
+export declare class DuckDbKnowledgeGraph {
+    private readonly executor;
+    constructor(executor: DuckDbExecutor);
+    initialize(): Promise<void>;
+    indexTreeSitterFile(payload: TreeSitterFileIndexPayload): Promise<void>;
+    traverse(startNodeId: string, maxDepth: number, direction?: GraphDirection): Promise<GraphTraversalRow[]>;
+}
+//# sourceMappingURL=knowledge-graph.d.ts.map

package/dist/core/sdd/knowledge-graph.js

@@ -0,0 +1,288 @@
+import { createHash } from 'node:crypto';
+export function resolveDuckDbConstructor(mod) {
+    const candidate = mod.default ?? mod;
+    if (typeof candidate === 'object' && candidate && 'Database' in candidate) {
+        const ctor = candidate.Database;
+        if (typeof ctor === 'function') {
+            return ctor;
+        }
+    }
+    if (typeof candidate === 'function') {
+        return candidate;
+    }
+    throw new Error('Unable to resolve DuckDB Database constructor from installed module.');
+}
+export async function createDuckDbExecutor(databasePath) {
+    let mod;
+    try {
+        const duckDbModuleName = 'duckdb';
+        mod = await import(duckDbModuleName);
+    }
+    catch {
+        throw new Error('DuckDB runtime is unavailable. Install the "duckdb" package to enable embedded knowledge graph queries.');
+    }
+    const DatabaseCtor = resolveDuckDbConstructor(mod);
+    const db = new DatabaseCtor(databasePath);
+    return {
+        run(sql, params = []) {
+            return new Promise((resolve, reject) => {
+                db.run(sql, [...params], (error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        },
+        all(sql, params = []) {
+            return new Promise((resolve, reject) => {
+                db.all(sql, [...params], (error, rows) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve((rows ?? []));
+                });
+            });
+        },
+        close() {
+            if (!db.close) {
+                return Promise.resolve();
+            }
+            return new Promise((resolve, reject) => {
+                db.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        },
+    };
+}
+export function normalizeGraphPath(value) {
+    return value.replace(/\\/g, '/');
+}
+export function hashSymbolId(filePath, symbolKey) {
+    return createHash('sha1').update(`${normalizeGraphPath(filePath)}::${symbolKey}`).digest('hex');
+}
+export function traversalSql(direction) {
+    if (direction === 'outbound') {
+        return `
+WITH RECURSIVE walk(depth, source_id, target_id, relation, visited) AS (
+  SELECT 1, source_id, target_id, relation, '|' || source_id || '|' || target_id || '|'
+  FROM adjacency_outbound
+  WHERE source_id = ?
+  UNION ALL
+  SELECT
+    walk.depth + 1,
+    next.source_id,
+    next.target_id,
+    next.relation,
+    walk.visited || next.target_id || '|'
+  FROM walk
+  JOIN adjacency_outbound AS next
+    ON next.source_id = walk.target_id
+  WHERE walk.depth < ?
+    AND instr(walk.visited, '|' || next.target_id || '|') = 0
+)
+SELECT depth, source_id, target_id, relation
+FROM walk
+ORDER BY depth, source_id, target_id, relation;
+`.trim();
+    }
+    return `
+WITH RECURSIVE walk(depth, source_id, target_id, relation, visited) AS (
+  SELECT 1, source_id, target_id, relation, '|' || target_id || '|' || source_id || '|'
+  FROM adjacency_inbound
+  WHERE target_id = ?
+  UNION ALL
+  SELECT
+    walk.depth + 1,
+    next.source_id,
+    next.target_id,
+    next.relation,
+    walk.visited || next.source_id || '|'
+  FROM walk
+  JOIN adjacency_inbound AS next
+    ON next.target_id = walk.source_id
+  WHERE walk.depth < ?
+    AND instr(walk.visited, '|' || next.source_id || '|') = 0
+)
+SELECT depth, source_id, target_id, relation
+FROM walk
+ORDER BY depth, source_id, target_id, relation;
+`.trim();
+}
+export class DuckDbKnowledgeGraph {
+    executor;
+    constructor(executor) {
+        this.executor = executor;
+    }
+    async initialize() {
+        await this.executor.run(`
+CREATE TABLE IF NOT EXISTS nodes (
+  id VARCHAR PRIMARY KEY,
+  kind VARCHAR NOT NULL,
+  name VARCHAR NOT NULL,
+  file_path VARCHAR NOT NULL,
+  language VARCHAR NOT NULL,
+  signature VARCHAR,
+  start_line INTEGER,
+  end_line INTEGER,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+`.trim());
+        await this.executor.run(`
+CREATE TABLE IF NOT EXISTS edges (
+  source_id VARCHAR NOT NULL,
+  target_id VARCHAR NOT NULL,
+  relation VARCHAR NOT NULL,
+  file_path VARCHAR NOT NULL,
+  weight INTEGER DEFAULT 1,
+  PRIMARY KEY (source_id, target_id, relation)
+);
+`.trim());
+        await this.executor.run(`
+CREATE TABLE IF NOT EXISTS adjacency_outbound (
+  source_id VARCHAR NOT NULL,
+  target_id VARCHAR NOT NULL,
+  relation VARCHAR NOT NULL,
+  file_path VARCHAR NOT NULL,
+  PRIMARY KEY (source_id, target_id, relation)
+);
+`.trim());
+        await this.executor.run(`
+CREATE TABLE IF NOT EXISTS adjacency_inbound (
+  target_id VARCHAR NOT NULL,
+  source_id VARCHAR NOT NULL,
+  relation VARCHAR NOT NULL,
+  file_path VARCHAR NOT NULL,
+  PRIMARY KEY (target_id, source_id, relation)
+);
+`.trim());
+    }
+    async indexTreeSitterFile(payload) {
+        const normalizedPath = normalizeGraphPath(payload.filePath);
+        const fileNodeId = `file:${normalizedPath}`;
+        const symbolNodeIds = new Map();
+        const edges = new Map();
+        for (const symbol of payload.symbols) {
+            const symbolKey = symbol.id ?? `${symbol.kind}:${symbol.name}:${symbol.startLine}:${symbol.endLine}`;
+            const nodeId = `symbol:${hashSymbolId(normalizedPath, symbolKey)}`;
+            symbolNodeIds.set(symbolKey, nodeId);
+            if (symbol.id) {
+                symbolNodeIds.set(symbol.id, nodeId);
+            }
+            edges.set(`${fileNodeId}|${nodeId}|contains`, {
+                sourceId: fileNodeId,
+                targetId: nodeId,
+                relation: 'contains',
+            });
+        }
+        for (const symbol of payload.symbols) {
+            const symbolKey = symbol.id ?? `${symbol.kind}:${symbol.name}:${symbol.startLine}:${symbol.endLine}`;
+            const nodeId = symbolNodeIds.get(symbolKey);
+            if (!nodeId) {
+                continue;
+            }
+            if (symbol.parentId) {
+                const parentNodeId = symbolNodeIds.get(symbol.parentId);
+                if (parentNodeId) {
+                    edges.set(`${parentNodeId}|${nodeId}|contains`, {
+                        sourceId: parentNodeId,
+                        targetId: nodeId,
+                        relation: 'contains',
+                    });
+                }
+            }
+            for (const referenceId of symbol.references ?? []) {
+                const targetNodeId = symbolNodeIds.get(referenceId);
+                if (!targetNodeId) {
+                    continue;
+                }
+                edges.set(`${nodeId}|${targetNodeId}|references`, {
+                    sourceId: nodeId,
+                    targetId: targetNodeId,
+                    relation: 'references',
+                });
+            }
+        }
+        await this.executor.run('BEGIN TRANSACTION');
+        try {
+            await this.executor.run('DELETE FROM adjacency_outbound WHERE file_path = ?', [normalizedPath]);
+            await this.executor.run('DELETE FROM adjacency_inbound WHERE file_path = ?', [normalizedPath]);
+            await this.executor.run('DELETE FROM edges WHERE file_path = ?', [normalizedPath]);
+            await this.executor.run('DELETE FROM nodes WHERE file_path = ?', [normalizedPath]);
+            await this.executor.run(`
+INSERT INTO nodes (id, kind, name, file_path, language, signature, start_line, end_line)
+VALUES (?, 'file', ?, ?, ?, NULL, NULL, NULL)
+`.trim(), [fileNodeId, normalizedPath, normalizedPath, payload.language]);
+            for (const symbol of payload.symbols) {
+                const symbolKey = symbol.id ?? `${symbol.kind}:${symbol.name}:${symbol.startLine}:${symbol.endLine}`;
+                const nodeId = symbolNodeIds.get(symbolKey);
+                if (!nodeId) {
+                    continue;
+                }
+                await this.executor.run(`
+INSERT INTO nodes (id, kind, name, file_path, language, signature, start_line, end_line)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+`.trim(), [
+                    nodeId,
+                    symbol.kind,
+                    symbol.name,
+                    normalizedPath,
+                    payload.language,
+                    symbol.signature ?? null,
+                    symbol.startLine,
+                    symbol.endLine,
+                ]);
+            }
+            for (const edge of edges.values()) {
+                await this.executor.run(`
+INSERT INTO edges (source_id, target_id, relation, file_path)
+VALUES (?, ?, ?, ?)
+`.trim(), [edge.sourceId, edge.targetId, edge.relation, normalizedPath]);
+                await this.executor.run(`
+INSERT INTO adjacency_outbound (source_id, target_id, relation, file_path)
+VALUES (?, ?, ?, ?)
+`.trim(), [edge.sourceId, edge.targetId, edge.relation, normalizedPath]);
+                await this.executor.run(`
+INSERT INTO adjacency_inbound (target_id, source_id, relation, file_path)
+VALUES (?, ?, ?, ?)
+`.trim(), [edge.targetId, edge.sourceId, edge.relation, normalizedPath]);
+            }
+            await this.executor.run('COMMIT');
+        }
+        catch (error) {
+            await this.executor.run('ROLLBACK');
+            throw error;
+        }
+    }
+    async traverse(startNodeId, maxDepth, direction = 'outbound') {
+        if (!Number.isInteger(maxDepth) || maxDepth < 1) {
+            throw new Error('maxDepth must be an integer greater than or equal to 1.');
+        }
+        if (direction === 'both') {
+            const outbound = await this.executor.all(traversalSql('outbound'), [startNodeId, maxDepth]);
+            const inbound = await this.executor.all(traversalSql('inbound'), [startNodeId, maxDepth]);
+            const merged = new Map();
+            for (const row of [...outbound, ...inbound]) {
+                merged.set(`${row.depth}|${row.source_id}|${row.target_id}|${row.relation}`, row);
+            }
+            return [...merged.values()].sort((left, right) => {
+                if (left.depth !== right.depth)
+                    return left.depth - right.depth;
+                if (left.source_id !== right.source_id)
+                    return left.source_id.localeCompare(right.source_id);
+                if (left.target_id !== right.target_id)
+                    return left.target_id.localeCompare(right.target_id);
+                return left.relation.localeCompare(right.relation);
+            });
+        }
+        return this.executor.all(traversalSql(direction), [startNodeId, maxDepth]);
+    }
+}
+//# sourceMappingURL=knowledge-graph.js.map