@abhinav2203/codeflow-core 0.1.0 → 1.0.0

package/dist/analyzer/tree-sitter-loader.js

@@ -0,0 +1,97 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Language, Parser } from "web-tree-sitter";
+const LANGUAGE_EXTENSIONS = {
+    go: [".go"],
+    python: [".py"],
+    c: [".c", ".h"],
+    cpp: [".cpp", ".cc", ".cxx", ".hpp"],
+    rust: [".rs"],
+    typescript: [".ts", ".tsx"],
+    javascript: [".js", ".jsx"]
+};
+const EXTENSION_TO_LANGUAGE = new Map();
+for (const [lang, exts] of Object.entries(LANGUAGE_EXTENSIONS)) {
+    for (const ext of exts) {
+        EXTENSION_TO_LANGUAGE.set(ext, lang);
+    }
+}
+const GRAMMAR_PACKAGE_NAMES = {
+    go: "tree-sitter-go",
+    python: "tree-sitter-python",
+    c: "tree-sitter-c",
+    cpp: "tree-sitter-cpp",
+    rust: "tree-sitter-rust",
+    typescript: "tree-sitter-typescript",
+    javascript: "tree-sitter-javascript"
+};
+const WASM_FILE_NAMES = {
+    go: "tree-sitter-go.wasm",
+    python: "tree-sitter-python.wasm",
+    c: "tree-sitter-c.wasm",
+    cpp: "tree-sitter-cpp.wasm",
+    rust: "tree-sitter-rust.wasm",
+    typescript: "tree-sitter-typescript.wasm",
+    javascript: "tree-sitter-javascript.wasm"
+};
+let parserInitialized = false;
+const initParser = async () => {
+    if (parserInitialized) {
+        return;
+    }
+    await Parser.init();
+    parserInitialized = true;
+};
+const loadedGrammars = new Map();
+const resolveWasmPath = (lang) => {
+    const packageName = GRAMMAR_PACKAGE_NAMES[lang];
+    const wasmFileName = WASM_FILE_NAMES[lang];
+    try {
+        // Use createRequire for ESM compatibility
+        const require = createRequire(import.meta.url);
+        const packagePath = require.resolve(`${packageName}/package.json`);
+        const packageDir = path.dirname(packagePath);
+        return path.join(packageDir, wasmFileName);
+    }
+    catch {
+        // Fallback to import.meta.resolve if available (Node 20.6+)
+        try {
+            const packageUrl = import.meta.resolve(`${packageName}/package.json`);
+            const packagePath = fileURLToPath(packageUrl);
+            const packageDir = path.dirname(packagePath);
+            return path.join(packageDir, wasmFileName);
+        }
+        catch {
+            throw new Error(`Cannot resolve WASM file for language "${lang}". ` +
+                `Ensure "${packageName}" is installed.`);
+        }
+    }
+};
+export const loadLanguage = async (lang) => {
+    if (loadedGrammars.has(lang)) {
+        return loadedGrammars.get(lang);
+    }
+    await initParser();
+    const wasmPath = resolveWasmPath(lang);
+    const language = await Language.load(wasmPath);
+    loadedGrammars.set(lang, language);
+    return language;
+};
+export const createParser = async (lang) => {
+    await initParser();
+    const parser = new Parser();
+    const language = await loadLanguage(lang);
+    parser.setLanguage(language);
+    return parser;
+};
+export const extensionToLanguage = (ext) => EXTENSION_TO_LANGUAGE.get(ext) ?? null;
+export const SUPPORTED_EXTENSIONS = new Set(EXTENSION_TO_LANGUAGE.keys());
+export const getLanguageFromPath = (filePath) => {
+    const ext = path.extname(filePath);
+    return extensionToLanguage(ext);
+};
+export const resetLoader = () => {
+    parserInitialized = false;
+    loadedGrammars.clear();
+};

package/dist/analyzer/tree-sitter-queries.d.ts

@@ -0,0 +1,10 @@
+import type { SupportedLanguage } from "./tree-sitter-loader.js";
+export interface LanguageQueries {
+    functions: string;
+    classes: string;
+    methods: string;
+    imports: string;
+    calls: string;
+    inherits: string;
+}
+export declare const QUERIES_BY_LANGUAGE: Record<SupportedLanguage, LanguageQueries>;

package/dist/analyzer/tree-sitter-queries.js

@@ -0,0 +1,285 @@
+const TS_JS_QUERIES = {
+    functions: `
+    (function_declaration
+      name: (identifier) @name
+      parameters: (formal_parameters) @params
+      return_type: (type_annotation)? @returnType
+      body: (statement_block) @body) @func
+    (generator_function_declaration
+      name: (identifier) @name
+      parameters: (formal_parameters) @params
+      return_type: (type_annotation)? @returnType
+      body: (statement_block) @body) @func
+  `,
+    classes: `
+    (class_declaration
+      name: (type_identifier) @name
+      heritage: (class_heritage
+        (identifier) @parent)?) @class
+    (class_declaration
+      name: (type_identifier) @name) @class
+  `,
+    methods: `
+    (method_definition
+      name: (property_identifier) @name
+      parameters: (formal_parameters) @params
+      return_type: (type_annotation)? @returnType
+      body: (statement_block) @body) @method
+  `,
+    imports: `
+    (import_statement
+      source: (string) @source) @import
+    (import_require_clause
+      source: (string) @source) @import
+  `,
+    calls: `
+    (call_expression
+      function: (identifier) @callee) @call
+    (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)) @call
+  `,
+    inherits: `
+    (class_heritage
+      (identifier) @parent) @inherits
+  `
+};
+const GO_QUERIES = {
+    functions: `
+    (function_declaration
+      name: (identifier) @name
+      parameters: (parameter_list) @params
+      result: (_) @returnType?
+      body: (block) @body) @func
+    (method_declaration
+      receiver: (parameter_list) @receiver
+      name: (field_identifier) @name
+      parameters: (parameter_list) @params
+      result: (_) @returnType?
+      body: (block) @body) @func
+  `,
+    classes: `
+    (type_declaration
+      declarator: (type_identifier) @name
+      type: (struct_type)) @class
+  `,
+    methods: `
+    (method_declaration
+      receiver: (parameter_list
+        (parameter_declaration
+          name: (identifier)? @receiverName
+          type: (_) @receiverType))
+      name: (field_identifier) @name
+      parameters: (parameter_list) @params
+      result: (_) @returnType?
+      body: (block) @body) @method
+  `,
+    imports: `
+    (import_declaration
+      (import_spec_list
+        (import_spec
+          path: (interpreted_string_literal) @source))) @import
+    (import_declaration
+      (import_spec
+        path: (interpreted_string_literal) @source)) @import
+  `,
+    calls: `
+    (call_expression
+      function: (identifier) @callee) @call
+    (call_expression
+      function: (selector_expression
+        field: (field_identifier) @callee)) @call
+    (call_expression
+      function: (qualified_identifier
+        name: (field_identifier) @callee)) @call
+  `,
+    inherits: `
+    (type_spec
+      type: (struct_type
+        (field_declaration
+          name: (field_identifier) @parent
+          type: (type_identifier)))) @inherits
+  `
+};
+const PYTHON_QUERIES = {
+    functions: `
+    (function_definition
+      name: (identifier) @name
+      parameters: (parameters) @params
+      return_type: (type)? @returnType
+      body: (block) @body) @func
+  `,
+    classes: `
+    (class_definition
+      name: (identifier) @name
+      superclasses: (argument_list
+        (identifier) @parent)?) @class
+    (class_definition
+      name: (identifier) @name) @class
+  `,
+    methods: `
+    (function_definition
+      name: (identifier) @name
+      parameters: (parameters) @params
+      return_type: (type)? @returnType
+      body: (block) @body) @method
+  `,
+    imports: `
+    (import_statement
+      name: (dotted_name) @source) @import
+    (import_from_statement
+      module_name: (dotted_name) @source) @import
+  `,
+    calls: `
+    (call
+      function: (identifier) @callee) @call
+    (call
+      function: (attribute
+        attribute: (identifier) @callee)) @call
+  `,
+    inherits: `
+    (argument_list
+      (identifier) @parent) @inherits
+  `
+};
+const C_QUERIES = {
+    functions: `
+    (function_definition
+      declarator: (function_declarator
+        declarator: (identifier) @name
+        parameters: (parameter_list) @params)
+      body: (compound_statement) @body) @func
+  `,
+    classes: ``,
+    methods: ``,
+    imports: `
+    (preproc_include
+      path: (system_lib_string) @source) @import
+    (preproc_include
+      path: (string_literal) @source) @import
+  `,
+    calls: `
+    (call_expression
+      function: (identifier) @callee) @call
+  `,
+    inherits: ``
+};
+const CPP_QUERIES = {
+    functions: `
+    (function_definition
+      declarator: (function_declarator
+        declarator: (identifier) @name
+        parameters: (parameter_list) @params)
+      body: (compound_statement) @body) @func
+    (function_definition
+      declarator: (function_declarator
+        declarator: (field_identifier) @name
+        parameters: (parameter_list) @params)
+      body: (compound_statement) @body) @func
+  `,
+    classes: `
+    (class_specifier
+      name: (type_identifier) @name
+      (base_class_clause
+        type: (type_identifier) @parent)?) @class
+    (class_specifier
+      name: (type_identifier) @name) @class
+    (struct_specifier
+      name: (type_identifier) @name
+      (base_class_clause
+        type: (type_identifier) @parent)?) @class
+    (struct_specifier
+      name: (type_identifier) @name) @class
+  `,
+    methods: `
+    (function_definition
+      declarator: (function_declarator
+        declarator: (field_identifier) @name
+        parameters: (parameter_list) @params)
+      body: (compound_statement) @body) @method
+  `,
+    imports: `
+    (preproc_include
+      path: (system_lib_string) @source) @import
+    (preproc_include
+      path: (string_literal) @source) @import
+    (import_declaration
+      (import_module) @source) @import
+  `,
+    calls: `
+    (call_expression
+      function: (identifier) @callee) @call
+    (call_expression
+      function: (field_expression
+        field: (field_identifier) @callee)) @call
+  `,
+    inherits: `
+    (base_class_clause
+      type: (type_identifier) @parent) @inherits
+  `
+};
+const RUST_QUERIES = {
+    functions: `
+    (function_item
+      name: (identifier) @name
+      parameters: (parameters) @params
+      return_type: (type_identifier)? @returnType
+      body: (block) @body) @func
+  `,
+    classes: `
+    (struct_item
+      name: (type_identifier) @name) @class
+    (enum_item
+      name: (type_identifier) @name) @class
+    (trait_item
+      name: (type_identifier) @name) @class
+    (impl_item
+      type: (type_identifier) @name
+      trait: (type_identifier)? @trait) @class
+  `,
+    methods: `
+    (function_item
+      name: (identifier) @name
+      parameters: (parameters
+        (self_parameter))? @self
+      return_type: (type_identifier)? @returnType
+      body: (block) @body) @method
+  `,
+    imports: `
+    (use_declaration
+      argument: (scoped_identifier
+        path: (identifier) @source)) @import
+    (use_declaration
+      argument: (scoped_identifier
+        (scoped_identifier
+          path: (identifier) @source))) @import
+    (use_declaration
+      argument: (identifier) @source) @import
+    (use_declaration
+      argument: (use_as_clause
+        path: (_) @source)) @import
+  `,
+    calls: `
+    (call_expression
+      function: (identifier) @callee) @call
+    (call_expression
+      function: (scoped_identifier
+        name: (identifier) @callee)) @call
+    (call_expression
+      function: (field_expression
+        field: (field_identifier) @callee)) @call
+  `,
+    inherits: `
+    (trait_bounds
+      (type_identifier) @parent) @inherits
+  `
+};
+export const QUERIES_BY_LANGUAGE = {
+    typescript: TS_JS_QUERIES,
+    javascript: TS_JS_QUERIES,
+    go: GO_QUERIES,
+    python: PYTHON_QUERIES,
+    c: C_QUERIES,
+    cpp: CPP_QUERIES,
+    rust: RUST_QUERIES
+};

package/dist/conflicts/index.d.ts

@@ -1,2 +1,2 @@
-import type { BlueprintGraph, ConflictReport } from "../schema/index";
+import type { BlueprintGraph, ConflictReport } from "../schema/index.js";
 export declare const detectGraphConflicts: (graph: BlueprintGraph, repoPath: string) => Promise<ConflictReport>;

package/dist/conflicts/index.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { analyzeTypeScriptRepo } from "../analyzer/repo";
+import { analyzeTypeScriptRepo } from "../analyzer/repo.js";
 const repoKeyForNode = (node) => `${node.kind}:${node.path ?? ""}:${node.name}`;
 export const detectGraphConflicts = async (graph, repoPath) => {
     const repoGraph = await analyzeTypeScriptRepo(path.resolve(repoPath));

package/dist/export/index.d.ts

@@ -1,2 +1,2 @@
-import type { BlueprintGraph, ExecutionReport, ExportResult } from "../schema/index";
+import type { BlueprintGraph, ExecutionReport, ExportResult } from "../schema/index.js";
 export declare const exportBlueprintArtifacts: (graph: BlueprintGraph, outputDir?: string, executionReport?: ExecutionReport, codeDrafts?: Record<string, string>) => Promise<ExportResult>;

package/dist/export/index.js

@@ -1,9 +1,9 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { generateNodeCode, getNodeStubPath, isCodeBearingNode } from "../internal/codegen";
-import { createRunPlan } from "../internal/plan";
-import { getCodeBearingNodes, getDefaultExecutionTarget } from "../internal/phases";
-import { slugify } from "../internal/utils";
+import { generateNodeCode, getNodeStubPath, isCodeBearingNode } from "../internal/codegen.js";
+import { createRunPlan } from "../internal/plan.js";
+import { getCodeBearingNodes, getDefaultExecutionTarget } from "../internal/phases.js";
+import { slugify } from "../internal/utils.js";
 const ensureDir = async (dirPath) => {
     await fs.mkdir(dirPath, { recursive: true });
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./analyzer/index";
-export * from "./schema/index";
-export * from "./export/index";
-export * from "./conflicts/index";
-export * from "./store-paths";
+export * from "./analyzer/index.js";
+export * from "./schema/index.js";
+export * from "./export/index.js";
+export * from "./conflicts/index.js";
+export * from "./store-paths.js";

package/dist/index.js

@@ -1,5 +1,5 @@
-export * from "./analyzer/index";
-export * from "./schema/index";
-export * from "./export/index";
-export * from "./conflicts/index";
-export * from "./store-paths";
+export * from "./analyzer/index.js";
+export * from "./schema/index.js";
+export * from "./export/index.js";
+export * from "./conflicts/index.js";
+export * from "./store-paths.js";

package/dist/internal/codegen.d.ts

@@ -1,4 +1,4 @@
-import type { BlueprintGraph, BlueprintNode } from "../schema/index";
+import type { BlueprintGraph, BlueprintNode } from "../schema/index.js";
 export declare const isCodeBearingNode: (node: BlueprintNode) => boolean;
 export declare const getNodeStubPath: (node: BlueprintNode) => string | null;
 export declare const getNodeRuntimeExport: (node: BlueprintNode) => string | null;

package/dist/internal/codegen.js

@@ -1,4 +1,4 @@
-import { emptyContract } from "../schema/index";
+import { emptyContract } from "../schema/index.js";
 export const isCodeBearingNode = (node) => node.kind !== "module";
 const normalizeContract = (contract) => ({
     ...emptyContract(),

package/dist/internal/phases.d.ts

@@ -1,4 +1,4 @@
-import type { BlueprintGraph, BlueprintNode, BlueprintPhase, NodeVerification, ExecutionStep, RuntimeExecutionResult } from "../schema/index";
+import type { BlueprintGraph, BlueprintNode, BlueprintPhase, NodeVerification, ExecutionStep, RuntimeExecutionResult } from "../schema/index.js";
 export declare const getCodeBearingNodes: (graph: BlueprintGraph) => BlueprintNode[];
 export declare const withSpecDrafts: (graph: BlueprintGraph) => BlueprintGraph;
 export declare const canCompleteSpecPhase: (graph: BlueprintGraph) => boolean;

package/dist/internal/phases.js

@@ -1,4 +1,4 @@
-import { generateNodeCode, isCodeBearingNode } from "./codegen";
+import { generateNodeCode, isCodeBearingNode } from "./codegen.js";
 export const getCodeBearingNodes = (graph) => graph.nodes.filter(isCodeBearingNode);
 export const withSpecDrafts = (graph) => ({
     ...graph,

package/dist/internal/plan.d.ts

@@ -1,2 +1,2 @@
-import type { BlueprintGraph, RunPlan } from "../schema/index";
+import type { BlueprintGraph, RunPlan } from "../schema/index.js";
 export declare const createRunPlan: (graph: BlueprintGraph) => RunPlan;

package/dist/internal/plan.js

@@ -1,4 +1,4 @@
-import { slugify } from "./utils";
+import { slugify } from "./utils.js";
 const taskOwnerPath = (node) => {
     const extension = node.kind === "ui-screen" ? "tsx" : "ts";
     return `stubs/${slugify(node.kind)}-${slugify(node.name)}.${extension}`;

package/dist/internal/prd.d.ts

@@ -1,4 +1,4 @@
-import type { BlueprintEdge, BlueprintNode, WorkflowPath } from "../schema/index";
+import type { BlueprintEdge, BlueprintNode, WorkflowPath } from "../schema/index.js";
 type PrdParseResult = {
     nodes: BlueprintNode[];
     edges: BlueprintEdge[];

package/dist/internal/prd.js

@@ -1,5 +1,5 @@
-import { emptyContract } from "../schema/index";
-import { createNode, createNodeId, dedupeEdges, mergeContracts, mergeSourceRefs } from "./utils";
+import { emptyContract } from "../schema/index.js";
+import { createNode, createNodeId, dedupeEdges, mergeContracts, mergeSourceRefs } from "./utils.js";
 const HEADING_PATTERN = /^#{1,6}\s+(.+)$/;
 const BULLET_PATTERN = /^[-*+]\s+(.*)$/;
 const WORKFLOW_PATTERN = /(.+?)\s*->\s*(.+)/;

package/dist/internal/utils.d.ts

@@ -1,4 +1,4 @@
-import type { BlueprintEdge, BlueprintNode, BlueprintNodeKind, CodeContract, ContractField, DesignCall, MethodSpec, SourceRef } from "../schema/index";
+import type { BlueprintEdge, BlueprintNode, BlueprintNodeKind, CodeContract, ContractField, DesignCall, MethodSpec, SourceRef } from "../schema/index.js";
 export declare const slugify: (value: string) => string;
 export declare const toPosixPath: (value: string) => string;
 export declare const createNodeId: (kind: BlueprintNodeKind, name: string, pathHint?: string) => string;

package/dist/internal/utils.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { emptyContract } from "../schema/index";
+import { emptyContract } from "../schema/index.js";
 export const slugify = (value) => value
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, "-")

package/dist/storage/store-paths.js

@@ -1,6 +1,6 @@
 import os from "node:os";
 import path from "node:path";
-import { slugify } from "../internal/utils";
+import { slugify } from "../internal/utils.js";
 const resolveDefaultStoreRoot = () => {
     if (process.env.VITEST || process.env.NODE_ENV === "test") {
         return path.join(process.cwd(), ".codeflow-store-test", `worker-${process.env.VITEST_WORKER_ID ?? "0"}`);

package/dist/store-paths.d.ts

@@ -1 +1 @@
-export { approvalPath, branchDirForProject, branchPath, checkpointPath, getStoreRoot, latestSessionPath, observabilityPath, runPath, sessionDirForProject, sessionHistoryPath } from "./storage/store-paths";
+export { approvalPath, branchDirForProject, branchPath, checkpointPath, getStoreRoot, latestSessionPath, observabilityPath, runPath, sessionDirForProject, sessionHistoryPath } from "./storage/store-paths.js";

package/dist/store-paths.js

@@ -1 +1 @@
-export { approvalPath, branchDirForProject, branchPath, checkpointPath, getStoreRoot, latestSessionPath, observabilityPath, runPath, sessionDirForProject, sessionHistoryPath } from "./storage/store-paths";
+export { approvalPath, branchDirForProject, branchPath, checkpointPath, getStoreRoot, latestSessionPath, observabilityPath, runPath, sessionDirForProject, sessionHistoryPath } from "./storage/store-paths.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abhinav2203/codeflow-core",
   "description": "Framework-agnostic CodeFlow analysis core for blueprint generation, repository analysis, exports, and conflict detection.",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,14 +39,25 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
     "prepare": "npm run build"
   },
   "dependencies": {
+    "tree-sitter-c": "^0.24.0",
+    "tree-sitter-cpp": "^0.23.4",
+    "tree-sitter-go": "^0.25.0",
+    "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-rust": "^0.24.0",
+    "tree-sitter-typescript": "^0.23.2",
     "ts-morph": "^27.0.2",
+    "web-tree-sitter": "^0.25.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.2"
   }
 }