Feature/c module (#140)

* Feature/c header resolver (#127)

* Added C parser

* Update package-lock.json

* Added C components to export

* Export parent classes of nested classes (#126)

* Types

* JSDoc comments

* First shot at parsing

* Why doesn't my autoformatter work anymore

* Added .c test file management

* Fixed property name

* Fixed property name

* First round of tests

* Fixed disastrous spelling mistake

* Feature/c symbol registry (#129)

* Added macros to header resolution

* Added safety for unnamed structs

* Typedef handling

* Handling of struct declaration inside a typedef

* Refactored tests

* Symbol registry

* New test file

* Added tests for registry

* Feature/c include resolver (#130)

* Include resolver

* Added tests to include resolver

* Tests for several internal includes

* Feature/c invocation resolver (#131)

* Removed (useless) specifier checking for symbols

* Invocation resolver

* Added definitionPath to functions

* Added getInvocationsForSymbol

* Added registration of undeclared functions such as main

* Tests for invocation resolver

* Feature/c manifest (#134)

* Dependency formatter

* Added tests to formatter

* C Manifest generation

* Added C function to handler

* Changed logic for function name resolution

* Added C to languages

* Fixed macro content not being parsed

* Improved include path logic

* Prevented overwriting of structs in header resolution

* Recursively looks through inclusions

* Changed standard inclusion data type

* Safer query for typedef double-definitions

* Updated JSDoc for header query

* Separated function definition and signature

* Emergency include resolution

* Update crashcases.h

* added metrics

* added metrics to manifest

* back merge main in to branch (#135)

* back merge main in to branch

* Fixed deno-exclusive errors

* Fixed lint

---------

Co-authored-by: LeBoufty <boufto@gmail.com>

* Feature/c extractor (#137)

* Update .gitignore

* Added test:watch task to cli

* Update deno.lock

* Added typedefs to datatypes' invocations

* Added C file content map to test files

* Added .napirc to C test files

* C Extractor

* C Extraction binding

* Class diagram

* Fixed formatting

* Feature/c warnings (#138)

* Forced datatypes to have names

* New test file

* Warning manager

* Added warnings to manifest generation

* Added enum member management

* Added support for unnamed enums

* Removed unnamed enums from diagnostics

* Fix/c manifest and extraction (#139)

* Fixed definesToKeep can have undefined

* Gave signature/definition linking responsibility to includeResolver

* Removed leftover logging

* Added caching to include resolution

* Changed internal inclusion structure

* Changed structure for included symbols

* Switched invocations to IncludedSymbol

* Added first-level include recursion management

* Removed includes for deleted files

* Includedirs and compaction

* Extraction refinement

* Fixed bad handling of typedefs with same name

* Improved recursive inclusion resolution

* Added credits

---------

Co-authored-by: Florian <florian.bigot321@gmail.com>

Author: LeBoufty

.gitignore

@@ -13,4 +13,5 @@ examples/csharp/EndpointExample/bin
 auditResponse.json
 .extracted/
 napi-output/
-coverage/
+coverage/
+.vite/

deno.lock

@@ -7,6 +7,7 @@ import pythonStdlibList from "../../../scripts/generate_python_stdlib_list/outpu
 import { confirm, input, number, search, select } from "@inquirer/prompts";
 import { globSync } from "npm:glob";
 import {
+  cLanguage,
   csharpLanguage,
   pythonLanguage,
 } from "../../../helpers/treeSitter/parsers.ts";
@@ -146,7 +147,7 @@ async function collectIncludePatterns(
 Include patterns define which files NanoAPI will process and analyze.
 
 Examples:
-- '**/*.py' for all Python files    
+- '**/*.py' for all Python files
 - 'src/**' for all files in src directory
 - '*.py' for all Python files in the root directory
 `,
@@ -500,6 +501,7 @@ export async function generateConfig(
     choices: [
       { name: "Python", value: pythonLanguage },
       { name: "C#", value: csharpLanguage },
+      { name: "C", value: cLanguage },
     ],
   });
 

packages/cli/src/cli/handlers/init/prompts.ts

@@ -33,8 +33,8 @@ export async function checkVersionMiddleware() {
     if (currentVersion !== latestVersion) {
       console.warn(
         `
-You are using version ${currentVersion}. 
-The latest version is ${latestVersion}. 
+You are using version ${currentVersion}.
+The latest version is ${latestVersion}.
 Please update to the latest version to continue using napi.
 
 You can update the version by running the following command:

packages/cli/src/cli/helpers/checkVersion.ts

@@ -4,14 +4,15 @@ import pythonStdlibList from "../scripts/generate_python_stdlib_list/output.json
   type: "json",
 };
 import {
+  cLanguage,
   csharpLanguage,
   pythonLanguage,
 } from "../helpers/treeSitter/parsers.ts";
 
 const pythonVersions = Object.keys(pythonStdlibList);
 
 export const localConfigSchema = z.object({
-  language: z.enum([pythonLanguage, csharpLanguage]),
+  language: z.enum([pythonLanguage, csharpLanguage, cLanguage]),
   [pythonLanguage]: z
     .object({
       version: z
@@ -24,6 +25,11 @@ export const localConfigSchema = z.object({
         .optional(),
     })
     .optional(), // python specific config
+  [cLanguage]: z
+    .object({
+      includedirs: z.array(z.string()).optional(),
+    })
+    .optional(), // c specific config
   project: z.object({
     include: z.array(z.string()),
     exclude: z.array(z.string()).optional(),

packages/cli/src/config/localConfig.ts

@@ -1,11 +1,16 @@
 import { globSync } from "npm:glob";
 import { dirname, join } from "@std/path";
-import { csharpLanguage, pythonLanguage } from "../treeSitter/parsers.ts";
+import {
+  cLanguage,
+  csharpLanguage,
+  pythonLanguage,
+} from "../treeSitter/parsers.ts";
 
 export function getExtensionsForLanguage(language: string) {
   const supportedLanguages: Record<string, string[]> = {
     [pythonLanguage]: ["py"],
     [csharpLanguage]: ["cs", "csproj"],
+    [cLanguage]: ["c", "h"],
   };
 
   const supportedLanguage = supportedLanguages[language];

packages/cli/src/helpers/fileSystem/index.ts

@@ -1,6 +1,7 @@
 import Parser, { type Language } from "npm:tree-sitter";
 import Python from "npm:tree-sitter-python";
 import CSharp from "npm:tree-sitter-c-sharp";
+import C from "npm:tree-sitter-c";
 
 const pythonParser = new Parser();
 pythonParser.setLanguage(Python as Language);
@@ -10,4 +11,15 @@ const csharpParser = new Parser();
 csharpParser.setLanguage(CSharp as Language);
 const csharpLanguage = CSharp.name as "c-sharp";
 
-export { csharpLanguage, csharpParser, pythonLanguage, pythonParser };
+const cParser = new Parser();
+cParser.setLanguage(C as Language);
+const cLanguage = C.name as "c";
+
+export {
+  cLanguage,
+  cParser,
+  csharpLanguage,
+  csharpParser,
+  pythonLanguage,
+  pythonParser,
+};

packages/cli/src/helpers/treeSitter/parsers.ts

@@ -0,0 +1,181 @@
+# NanoAPI C Plugin
+
+This plugin manages parsing and mapping of dependencies in C projects.
+
+**Warning :** This plugin relies on tree-sitter, which has an unreliable parser
+for C. Not every C project is entirely compatible. Warnings may be issued where
+tree-sitter finds errors.
+
+## Class diagram
+
+```mermaid
+classDiagram
+    class CMetricsAnalyzer {
+        +analyzeNode(node: Parser.SyntaxNode): CComplexityMetrics
+    }
+
+    class CExtractor {
+        -manifest: DependencyManifest
+        -registry: Map<string, CFile>
+        -includeResolver: CIncludeResolver
+        +extractSymbols(symbolsMap: Map<string, SymbolsToExtract>): Map<string, File>
+    }
+
+    class CSymbolRegistry {
+        -headerResolver: CHeaderResolver
+        -files: Map<string, File>
+        +getRegistry(): Map<string, CFile>
+    }
+
+    class CHeaderResolver {
+        +resolveSymbols(file: File): ExportedSymbol[]
+    }
+
+    class CIncludeResolver {
+        -symbolRegistry: Map<string, CFile>
+        -files: Map<string, File>
+        +getInclusions(): Map<string, Inclusions>
+    }
+
+    class CInvocationResolver {
+        -includeResolver: CIncludeResolver
+        +getInvocationsForSymbol(symbol: Symbol): Invocations
+        +getInvocationsForFile(filepath: string): Invocations
+    }
+
+    class CDependencyFormatter {
+        -symbolRegistry: CSymbolRegistry
+        -includeResolver: CIncludeResolver
+        -invocationResolver: CInvocationResolver
+        +formatFile(filepath: string): CDepFile
+    }
+
+    class Symbol {
+        <<abstract>>
+        -name: string
+        -declaration: ExportedSymbol
+    }
+
+    class FunctionSignature {
+        -definition: FunctionDefinition
+        -isMacro: boolean
+    }
+
+    class FunctionDefinition {
+        -signature: FunctionSignature
+        -isMacro: boolean
+    }
+
+    class DataType {
+        -typedefs: Map<string, Typedef>
+    }
+
+    class Typedef {
+        -datatype: DataType
+    }
+
+    class Variable {
+        -isMacro: boolean
+    }
+
+    class CFile {
+        -file: File
+        -symbols: Map<string, Symbol>
+        -type: CFileType
+    }
+
+    class ExportedSymbol {
+        -name: string
+        -type: SymbolType
+        -specifiers: StorageClassSpecifier[]
+        -qualifiers: TypeQualifier[]
+        -node: Parser.SyntaxNode
+        -identifierNode: Parser.SyntaxNode
+        -filepath: string
+    }
+
+    class Inclusions {
+        -filepath: string
+        -symbols: Map<string, Symbol>
+        -internal: string[]
+        -standard: Map<string, Parser.SyntaxNode>
+    }
+
+    class Invocations {
+        -resolved: Map<string, Symbol>
+        -unresolved: Set<string>
+    }
+
+    class CDependency {
+        -id: string
+        -isExternal: boolean
+        -symbols: Record<string, string>
+    }
+
+    class CDepFile {
+        -id: string
+        -filePath: string
+        -rootNode: Parser.SyntaxNode
+        -lineCount: number
+        -characterCount: number
+        -dependencies: Record<string, CDependency>
+        -symbols: Record<string, CDepSymbol>
+    }
+
+    class CDepSymbol {
+        -id: string
+        -type: CDepSymbolType
+        -lineCount: number
+        -characterCount: number
+        -node: Parser.SyntaxNode
+        -dependents: Record<string, CDependent>
+        -dependencies: Record<string, CDependency>
+    }
+
+    class CComplexityMetrics {
+        -cyclomaticComplexity: number
+        -codeLinesCount: number
+        -linesCount: number
+        -codeCharacterCount: number
+        -characterCount: number
+    }
+
+    class CodeCounts {
+        -lines: number
+        -characters: number
+    }
+
+    class CommentSpan {
+        -start: Point
+        -end: Point
+    }
+
+    %% Relationships
+    Symbol <|-- FunctionSignature
+    Symbol <|-- FunctionDefinition
+    Symbol <|-- DataType
+    Symbol <|-- Typedef
+    Symbol <|-- Variable
+    CSymbolRegistry --> CFile
+    CSymbolRegistry --> CHeaderResolver
+    CIncludeResolver --> CSymbolRegistry
+    CInvocationResolver --> CIncludeResolver
+    CDependencyFormatter --> CSymbolRegistry
+    CDependencyFormatter --> CIncludeResolver
+    CDependencyFormatter --> CInvocationResolver
+    CExtractor --> CSymbolRegistry
+    CExtractor --> CIncludeResolver
+    CExtractor --> CFile
+    CFile --> Symbol
+    Typedef --> DataType
+    DataType --> Typedef
+    Invocations --> Symbol
+    Inclusions --> Symbol
+    CDepFile --> CDependency
+    CDepFile --> CDepSymbol
+    CDepSymbol --> CDependent
+    CDepSymbol --> CDependency
+    CMetricsAnalyzer --> CComplexityMetrics
+    CMetricsAnalyzer --> CodeCounts
+    CMetricsAnalyzer --> CommentSpan
+```

packages/cli/src/languagePlugins/c/README.md

@@ -0,0 +1,66 @@
+import { describe, test } from "@std/testing/bdd";
+import { expect } from "@std/expect";
+import { cFilesFolder, getCFilesMap } from "../testFiles/index.ts";
+import { CDependencyFormatter } from "./index.ts";
+import { join } from "@std/path";
+
+describe("CDependencyFormatter", () => {
+  const cFilesMap = getCFilesMap();
+  const depFormatter = new CDependencyFormatter(cFilesMap);
+  const burgersh = join(cFilesFolder, "burgers.h");
+  const burgersc = join(cFilesFolder, "burgers.c");
+  const personnelh = join(cFilesFolder, "personnel.h");
+  const main = join(cFilesFolder, "main.c");
+
+  test("main.c", () => {
+    const fmain = depFormatter.formatFile(main);
+    expect(fmain).toBeDefined();
+    expect(fmain.id).toBe(main);
+    expect(fmain.dependencies[burgersh]).toBeDefined();
+    expect(fmain.dependencies[burgersc]).not.toBeDefined();
+    expect(fmain.dependencies[personnelh]).toBeDefined();
+    expect(fmain.dependencies["<stdio.h>"]).toBeDefined();
+    expect(fmain.dependencies[personnelh].isExternal).toBe(false);
+    expect(fmain.dependencies[burgersh].isExternal).toBe(false);
+    expect(fmain.dependencies["<stdio.h>"].isExternal).toBe(true);
+    expect(fmain.dependencies[burgersh].symbols["Burger"]).toBeDefined();
+    expect(fmain.dependencies[burgersh].symbols["create_burger"]).toBeDefined();
+    expect(fmain.dependencies[personnelh].symbols["Employee"]).toBeDefined();
+    expect(
+      fmain.dependencies[personnelh].symbols["create_employee"],
+    ).toBeDefined();
+    expect(
+      fmain.dependencies[personnelh].symbols["print_employee_details"],
+    ).toBeDefined();
+    expect(fmain.symbols["main"]).toBeDefined();
+    expect(fmain.symbols["main"].type).toBe("function");
+    expect(fmain.symbols["main"].lineCount > 1).toBe(true);
+    expect(fmain.symbols["main"].characterCount > 1).toBe(true);
+    expect(fmain.symbols["main"].dependents).toBeDefined();
+    expect(fmain.symbols["main"].dependencies).toBeDefined();
+    expect(fmain.symbols["main"].dependencies[burgersh]).toBeDefined();
+    expect(fmain.symbols["main"].dependencies[burgersh].isExternal).toBe(false);
+    expect(fmain.symbols["main"].dependencies[burgersh].symbols["Burger"]).toBe(
+      "Burger",
+    );
+    expect(
+      fmain.symbols["main"].dependencies[burgersh].symbols["create_burger"],
+    ).toBe("create_burger");
+    expect(fmain.symbols["main"].dependencies[personnelh]).toBeDefined();
+    expect(fmain.symbols["main"].dependencies[personnelh].isExternal).toBe(
+      false,
+    );
+    expect(
+      fmain.symbols["main"].dependencies[personnelh].symbols["Employee"],
+    ).toBe("Employee");
+    expect(
+      fmain.symbols["main"].dependencies[personnelh].symbols["create_employee"],
+    ).toBe("create_employee");
+    expect(
+      fmain.symbols["main"].dependencies[personnelh].symbols[
+        "print_employee_details"
+      ],
+    ).toBe("print_employee_details");
+    expect(fmain.symbols["main"].dependencies["<stdio.h>"]).not.toBeDefined();
+  });
+});