@g3nomaly/analyze 0.0.0-stage → 0.1.1

package/dist/scanner/sql/query.d.ts

@@ -0,0 +1,73 @@
+import type { QueryEffect, QueryTable } from '../../model';
+/**
+ * A column a statement names.
+ *
+ * @property table - Name of the table in front of the column, with an alias replaced by its table. `null` for a column without one.
+ * @property column - Name of the column. `*` for every column.
+ */
+export interface ParsedColumnRef {
+    readonly table: string | null;
+    readonly column: string;
+}
+/**
+ * One placeholder of a statement.
+ *
+ * @property name - The placeholder as written: `:map_id`, `@id`, `$id`, `?2`. A plain `?` gets the number SQLite gives it: `?1`.
+ * @property column - The column the placeholder is compared with or stored in, when the statement shows one.
+ * @property count - True for the row count of a `LIMIT` or an `OFFSET`.
+ */
+export interface ParsedParameter {
+    readonly name: string;
+    readonly column: ParsedColumnRef | null;
+    readonly count: boolean;
+}
+/**
+ * One column of the rows a statement returns.
+ *
+ * @property name - Name of the column in the result: its alias, else the column it selects, else the expression as written. `*` and `t.*` stand for every column of a table.
+ * @property expression - The expression behind an alias, as written. `''` for a column of a table.
+ * @property column - The column of a table it selects. `null` for an expression.
+ */
+export interface ParsedResultColumn {
+    readonly name: string;
+    readonly expression: string;
+    readonly column: ParsedColumnRef | null;
+}
+/** A table a statement names, and what it does with it. */
+export type ParsedQueryTable = Pick<QueryTable, 'name' | 'access'>;
+/**
+ * One entry of a query catalog, as its file writes it.
+ *
+ * @property name - Name from a `-- name:` line above the SQL. `null` when the file has no such line, so the file names the entry.
+ * @property line - 1-based line the SQL starts on.
+ * @property effect - Whether the statement reads, writes or only controls.
+ * @property verb - The keywords that open the statement, in capitals: `SELECT`, `INSERT`, `BEGIN IMMEDIATE`.
+ * @property note - Markdown from the comments above the SQL.
+ * @property sql - The SQL as written, without the closing semicolon.
+ * @property parameters - Placeholders in the order SQLite numbers them, each once.
+ * @property tables - Tables the statement names, in the order they first appear, each once per access.
+ * @property columns - Result columns in result order. Empty for a statement that returns no rows.
+ */
+export interface ParsedQuery {
+    readonly name: string | null;
+    readonly line: number;
+    readonly effect: QueryEffect;
+    readonly verb: string;
+    readonly note: string;
+    readonly sql: string;
+    readonly parameters: readonly ParsedParameter[];
+    readonly tables: readonly ParsedQueryTable[];
+    readonly columns: readonly ParsedResultColumn[];
+}
+/**
+ * @brief Reads a SQL file of a query catalog: a file of queries and statements that
+ * creates no table. The SQL is read as text and never run.
+ *
+ * A file is one entry, named by the file. A file that names its statements
+ * with comment lines such as `-- name: list_bookings` is one entry per name.
+ * The comments above the SQL of an entry are its note.
+ *
+ * @param source - Text of the file.
+ * @returns The entries in file order. Empty for a file without a statement.
+ */
+export declare function parseQueryFile(source: string): ParsedQuery[];

package/dist/scanner/sql/registry.d.ts

@@ -0,0 +1,63 @@
+import type { NodeRef } from '../../model';
+/**
+ * A column of a table as the registry knows it.
+ *
+ * @property ref - Node of the column.
+ * @property name - Name of the column, as its table writes it.
+ * @property type - Declared type, or `''`.
+ */
+export interface ColumnEntry {
+    readonly ref: NodeRef;
+    readonly name: string;
+    readonly type: string;
+}
+/**
+ * A table as the registry knows it.
+ *
+ * @property ref - Node of the table.
+ * @property name - Name of the table, as its statement writes it.
+ * @property path - Display path (`SourceFile.displayPath`) of the file that creates the table.
+ * @property primaryKey - Columns of its primary key, in key order.
+ * @property columns - Its columns, in table order.
+ */
+export interface TableEntry {
+    readonly ref: NodeRef;
+    readonly name: string;
+    readonly path: string;
+    readonly primaryKey: readonly string[];
+    readonly columns: readonly ColumnEntry[];
+}
+/**
+ * Finds a column of a table by name. Capitals do not matter, as in SQLite.
+ *
+ * @param table - The table to search.
+ * @param name - Name of the column, in any case.
+ * @returns The column, or `undefined` when the table has none of that name.
+ */
+export declare function columnOf(table: TableEntry, name: string): ColumnEntry | undefined;
+/**
+ * @brief Finds tables by name across the SQL files of one scan.
+ *
+ * `SqlPlanner` registers every table when it adds it, and looks tables up
+ * when the content of the graph is built. By then every file is read, so a
+ * foreign key can point at a table of a later file. `CatalogPlanner` looks
+ * up the tables and columns that queries name. Holds the tables by their
+ * lowercase name. `RepositoryScanner` creates one per scan and hands it to
+ * both planners.
+ */
+export declare class TableRegistry {
+    private readonly byName;
+    /**
+     * Records a table under its name. Capitals of the name do not matter, as in SQLite.
+     *
+     * @param entry - The table to record.
+     */
+    register(entry: TableEntry): void;
+    /**
+     * Finds the table a name in a SQL file means.
+     *
+     * @param path - Display path of the file the name is in, as in `TableEntry.path`.
+     * @returns The table of that name in the same file, else the only table of that name in the scan, else `null`.
+     */
+    find(name: string, path: string): TableEntry | null;
+}

package/dist/scanner/sql/source.d.ts

@@ -0,0 +1,10 @@
+import type { SourceFile } from '../code/planner';
+import type { Reporter } from '../reporter';
+/**
+ * Reads the text of a SQL file.
+ *
+ * @param file - The SQL file to read, with its root and path.
+ * @param reporter - Receives a warning when the file cannot be read.
+ * @returns The text, or `null` for a file that is too large or cannot be read.
+ */
+export declare function readSqlFile(file: SourceFile, reporter: Reporter): Promise<string | null>;

package/dist/scanner/sql/statements.d.ts

@@ -0,0 +1,42 @@
+import type { SqlComment, SqlToken } from './tokens';
+/**
+ * Turns comments into markdown.
+ *
+ * @param comments - Comments in file order.
+ * @returns Their text without ruler lines and shared indentation. Comments that are apart become paragraphs.
+ */
+export declare function markdownOf(comments: readonly SqlComment[]): string;
+/**
+ * @brief Finds the comments that describe what starts on a line: the comments on
+ * lines of their own directly above it, without a blank line between.
+ *
+ * @param comments - Every comment of the file, in file order.
+ * @param line - 1-based line the described statement or column starts on.
+ * @returns The comments, in file order.
+ */
+export declare function commentsAbove(comments: readonly SqlComment[], line: number): SqlComment[];
+/**
+ * One statement of a file: the tokens it is made of, without its closing semicolon.
+ *
+ * @property tokens - Tokens of the statement, in text order.
+ */
+export interface Statement {
+    readonly tokens: readonly SqlToken[];
+}
+/**
+ * @brief Splits the tokens of a file into statements at the semicolons. The
+ * semicolons inside the body of a trigger do not end its statement.
+ *
+ * @param tokens - Every token of the file.
+ * @returns The statements, each without its closing semicolon.
+ */
+export declare function statementsOf(tokens: readonly SqlToken[]): Statement[];
+/**
+ * Reads a statement back as written.
+ *
+ * @param source - Text of the whole file.
+ * @param first - Token the statement starts with.
+ * @param last - Token the statement ends with.
+ * @returns The statement with its line breaks, without the closing semicolon.
+ */
+export declare function sqlOf(source: string, first: SqlToken, last: SqlToken): string;

package/dist/scanner/sql/tokens.d.ts

@@ -0,0 +1,51 @@
+/** What a token of a SQL text is. A `name` is a quoted identifier. */
+export type SqlTokenKind = 'word' | 'name' | 'string' | 'number' | 'symbol';
+/**
+ * One token of a SQL text. Comments are no tokens.
+ *
+ * @property kind - What the token is.
+ * @property value - The token without quotes and escapes. For a word, a number or a symbol: the token as written.
+ * @property line - 1-based line the token starts on.
+ * @property endLine - 1-based line the token ends on.
+ * @property start - Offset of the first character in the text.
+ * @property end - Offset behind the last character.
+ */
+export interface SqlToken {
+    readonly kind: SqlTokenKind;
+    readonly value: string;
+    readonly line: number;
+    readonly endLine: number;
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * One comment of a SQL text.
+ *
+ * @property lines - The comment without its markers, one entry per line.
+ * @property line - 1-based line the comment starts on.
+ * @property endLine - 1-based line the comment ends on.
+ * @property alone - True when no token is in front of the comment on its line.
+ */
+export interface SqlComment {
+    readonly lines: readonly string[];
+    readonly line: number;
+    readonly endLine: number;
+    readonly alone: boolean;
+}
+/**
+ * The tokens and the comments of a SQL text, from `tokenizeSql`.
+ *
+ * @property tokens - Tokens in text order.
+ * @property comments - Comments apart from the tokens, in text order.
+ */
+export interface SqlTokens {
+    readonly tokens: readonly SqlToken[];
+    readonly comments: readonly SqlComment[];
+}
+/**
+ * Splits a SQL text into tokens and comments.
+ *
+ * @param source - The SQL text, as written in the file.
+ * @returns The tokens in text order, and the comments apart from them. Text that is no SQL becomes symbol tokens, so the function never fails.
+ */
+export declare function tokenizeSql(source: string): SqlTokens;

package/dist/scanner/tasks/layout.d.ts

@@ -0,0 +1,52 @@
+/** Folder of a phase that holds its task files. */
+export declare const TASKS_DIR = "tasks";
+/** Folder of a plan that holds its decision files. */
+export declare const DECISIONS_DIR = "decisions";
+/** File at the root of the tree that holds its terms. */
+export declare const VOCABULARY_FILE = "vocabulary.md";
+/**
+ * A phase of the tree as its files lay it out.
+ *
+ * @property name - Folder name of the phase.
+ * @property file - Tree-relative path of `<plan>/<phase>/<phase>.md`.
+ * @property tasks - Tree-relative paths of the task files, sorted by name.
+ */
+export interface PhaseFiles {
+    readonly name: string;
+    readonly file: string;
+    readonly tasks: readonly string[];
+}
+/**
+ * A plan of the tree as its files lay it out.
+ *
+ * @property name - Folder name of the plan.
+ * @property file - Tree-relative path of `<plan>/<plan>.md`.
+ * @property phases - Sorted by folder name, which is the order task-manager queues them in.
+ * @property decisions - Tree-relative paths of the decision files, sorted by name.
+ */
+export interface PlanFiles {
+    readonly name: string;
+    readonly file: string;
+    readonly phases: readonly PhaseFiles[];
+    readonly decisions: readonly string[];
+}
+/**
+ * The task tree as its files lay it out.
+ *
+ * @property plans - Plans in folder order.
+ * @property vocabulary - Tree-relative path of the vocabulary, or `null` when the tree has none.
+ */
+export interface TreeFiles {
+    readonly plans: readonly PlanFiles[];
+    readonly vocabulary: string | null;
+}
+/**
+ * @brief Sorts the files of a task tree into plans, phases, tasks and decisions by
+ * where they are: `<plan>/<plan>.md`, `<plan>/<phase>/<phase>.md`,
+ * `<plan>/<phase>/tasks/<id>.md` and `<plan>/decisions/<id>.md`. Index files
+ * and any other file are left out, since task-manager derives them.
+ *
+ * @param files - Paths relative to the root of the tree, in POSIX form.
+ * @returns The plans in folder order, each with its phases and decisions.
+ */
+export declare function layoutTree(files: readonly string[]): TreeFiles;

package/dist/scanner/tasks/planner.d.ts

@@ -0,0 +1,130 @@
+import type { NodeRef } from '../../model';
+import type { FileRenderer } from '../content';
+import type { Source } from '../files';
+import type { GlossaryPlanner } from '../glossary/planner';
+import type { GraphBuilder } from '../graph/builder';
+import type { ProseResolvers } from '../markdown/links';
+import type { MarkdownRenderer } from '../markdown/renderer';
+import type { Reporter } from '../reporter';
+/**
+ * The task tree of one scan: the files below its directory, with paths relative to the scanned root.
+ *
+ * @property dir - Root-relative POSIX path of the tree, such as `docs/task-manager`.
+ */
+export interface TaskTreeSource extends Source {
+    readonly dir: string;
+}
+/**
+ * @brief Adds the tasks section to the graph from a task-manager tree: one `plan`
+ * page per plan, one `phase` page per phase, one `task` entry per task file,
+ * a `decisions` page per plan with decision files, and the `vocabulary.md`
+ * of the tree as a glossary. Created by `RepositoryScanner` for every scan.
+ *
+ * What a plan, a phase or a task links to or names in inline code becomes a
+ * `names` edge, and every `depends_on` a `depends` edge. A file whose
+ * frontmatter fails its schema is reported and shown as a plain document.
+ *
+ * Holds the graph, the file renderer, the markdown renderer, the prose
+ * resolvers, the `GlossaryPlanner` for the vocabulary and the reporter for
+ * warnings.
+ *
+ * @example
+ * await new TaskPlanner(graph, files, markdown, resolvers, glossaries, reporter).plan(sections.tasks, input.tasks);
+ */
+export declare class TaskPlanner {
+    private readonly graph;
+    private readonly files;
+    private readonly markdown;
+    private readonly resolvers;
+    private readonly glossaries;
+    private readonly reporter;
+    /**
+     * Creates a planner.
+     *
+     * @param graph - Graph the tasks section is added to.
+     * @param files - Renders the markdown pages of plans and phases.
+     * @param markdown - Renders the bodies of tasks and decisions.
+     * @param resolvers - Resolves the links and inline code of each page.
+     * @param glossaries - Adds the vocabulary file as a glossary.
+     * @param reporter - Receives a warning for every file that fails its schema and every `depends_on` that names nothing.
+     */
+    constructor(graph: GraphBuilder, files: FileRenderer, markdown: MarkdownRenderer, resolvers: ProseResolvers, glossaries: GlossaryPlanner, reporter: Reporter);
+    /**
+     * Adds every plan of the trees, with its phases, tasks and decisions.
+     *
+     * @param section - Node of the tasks section.
+     * @param trees - The task trees of the scan. Usually one, or none when the repository keeps no tasks.
+     */
+    plan(section: NodeRef, trees: readonly TaskTreeSource[]): Promise<void>;
+    /**
+     * Adds one plan with its phases and decisions.
+     *
+     * @param section - Node of the tasks section the plan goes under.
+     * @param tree - Task tree the plan's files are read from.
+     * @param plan - Files of the plan, from `layoutTree`.
+     * @param targets - Nodes that `depends_on` names can point at, filled as nodes are added.
+     * @param pending - Dependencies to resolve once every node exists.
+     */
+    private planPlan;
+    /**
+     * Adds one phase with its tasks.
+     *
+     * @param planRef - Node of the plan the phase belongs to.
+     * @param tree - Task tree the phase's files are read from.
+     * @param phase - Files of the phase, from `layoutTree`.
+     * @param phases - Phase nodes of this plan, by phase name.
+     * @param targets - Nodes that `depends_on` names can point at, filled as nodes are added.
+     * @param pending - Dependencies to resolve once every node exists.
+     */
+    private planPhase;
+    /**
+     * Adds the decision log of a plan: one `decisions` page for its folder and one `decision` entry per file.
+     *
+     * @param planRef - Node of the plan the log belongs to.
+     * @param tree - Task tree the decision files are read from.
+     * @param plan - Files of the plan, from `layoutTree`.
+     * @param paths - Tree-relative paths of the decision files.
+     */
+    private planDecisions;
+    /**
+     * Renders the page of a plan or a phase whose frontmatter passed its schema.
+     *
+     * @param self - Node the page is rendered for.
+     * @param read - The file that holds the page.
+     * @param meta - Parsed frontmatter of the file.
+     * @returns The content of the node: the rendered file, its title and summary, and where it stands.
+     */
+    private renderTracked;
+    /**
+     * Adds a tree file whose frontmatter failed its schema as a plain document.
+     *
+     * @param parent - Node the document goes under.
+     * @param read - The file to show as a document.
+     * @returns The node of the document.
+     */
+    private planDocument;
+    /**
+     * Checks the frontmatter of a file against its schema, and reports the file when it fails.
+     *
+     * @param schema - Schema the frontmatter must match.
+     * @param read - The file whose frontmatter is checked.
+     * @returns The parsed frontmatter, or `null` when it failed.
+     */
+    private parse;
+    /**
+     * Reads a file of the tree and splits off its frontmatter.
+     *
+     * @param tree - Task tree the file belongs to.
+     * @param treePath - Path of the file relative to the tree.
+     * @returns The file with its frontmatter, body and source text.
+     */
+    private read;
+    /**
+     * The paths of a tree file as the planners of the docs section take them.
+     *
+     * @param tree - Task tree the file belongs to.
+     * @param treePath - Path of the file relative to the tree.
+     * @returns The file with its root, root-relative path and display path.
+     */
+    private docFile;
+}

package/dist/scanner/tasks/schema.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+/** Frontmatter of a plan file, `<plan>/<plan>.md`. Fields the site does not show are let through unread. */
+export declare const PlanFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    priority: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    summary: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        "in-progress": "in-progress";
+        "in-review": "in-review";
+        open: "open";
+    }>;
+}, z.core.$strip>;
+/** Parsed frontmatter of a plan file. */
+export type PlanFrontmatter = z.infer<typeof PlanFrontmatterSchema>;
+/** Frontmatter of a phase file, `<plan>/<phase>/<phase>.md`. task-manager spells the parallel flag `parrallel`. */
+export declare const PhaseFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    priority: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    summary: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        "in-progress": "in-progress";
+        "in-review": "in-review";
+        open: "open";
+    }>;
+    parrallel: z.ZodOptional<z.ZodBoolean>;
+    parallel: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Parsed frontmatter of a phase file. */
+export type PhaseFrontmatter = z.infer<typeof PhaseFrontmatterSchema>;
+/** Frontmatter of a task file, `<plan>/<phase>/tasks/<id>.md`. */
+export declare const TaskFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    package: z.ZodString;
+    priority: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    summary: z.ZodString;
+    complexity: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        "in-progress": "in-progress";
+        "in-review": "in-review";
+        open: "open";
+    }>;
+}, z.core.$strip>;
+/** Parsed frontmatter of a task file. */
+export type TaskFrontmatter = z.infer<typeof TaskFrontmatterSchema>;
+/** Frontmatter of a decision file in a plan's `decisions/` folder. */
+export declare const DecisionFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodString;
+    date: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    supersedes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Parsed frontmatter of a decision file. */
+export type DecisionFrontmatter = z.infer<typeof DecisionFrontmatterSchema>;
+/**
+ * Describes why a frontmatter block failed its schema, for a warning.
+ *
+ * @param error - The error of a failed `safeParse`.
+ * @returns The issues joined, such as `status: Invalid option; summary: Required`.
+ */
+export declare function describeIssues(error: z.ZodError): string;

package/dist/scanner/text.d.ts

@@ -0,0 +1,14 @@
+/** Turns a text into a lowercase, hyphen-separated identifier that is safe in a URL path segment, or `untitled`. */
+export declare function slugify(value: string): string;
+/** Returns `base`, or `base-2`, `base-3`… when `base` is already in `taken`, and adds the result to `taken`. */
+export declare function uniqueId(base: string, taken: Set<string>, separator?: string): string;
+/** Removes the indentation shared by every non-blank line. */
+export declare function dedent(text: string): string;
+/** Dedents and drops leading and trailing blank lines. */
+export declare function trimBlock(text: string): string;
+/** Escapes `&`, `<`, `>` and `"` for HTML text and attribute values. */
+export declare function escapeHtml(value: string): string;
+/** Converts a name in any case to camelCase, such as `user_id` to `userId`. */
+export declare function toCamelCase(name: string): string;
+/** Converts a name in any case to snake_case, such as `userId` to `user_id`. */
+export declare function toSnakeCase(name: string): string;

package/package.json

@@ -1,6 +1,106 @@
 {
   "name": "@g3nomaly/analyze",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Turns a repository into one offline HTML documentation site, and queries the same linked model from the terminal and from hooks.",
+  "keywords": [
+    "documentation",
+    "docs",
+    "generator",
+    "cli",
+    "bun",
+    "tree-sitter",
+    "skills",
+    "tasks",
+    "openapi",
+    "json-schema",
+    "sqlite",
+    "semantic-search"
+  ],
+  "type": "module",
+  "bin": {
+    "g3n-analyze": "./dist/cli.js"
+  },
+  "module": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "bun": ">=1.2.21"
+  },
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test tests/unit",
+    "test:integration": "bun run build && bun test tests/integration",
+    "analyze": "bun run src/cli/index.ts",
+    "docs": "bun run build && bun dist/cli.js create_docs"
+  },
+  "dependencies": {
+    "@g3nomaly/core": "^0.3.2",
+    "@t3-oss/env-core": "^0.13.11",
+    "hast-util-to-string": "^3.0.1",
+    "rehype-parse": "^9.0.1",
+    "rehype-remark": "^10.0.1",
+    "rehype-slug": "^6.0.0",
+    "rehype-stringify": "^10.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "remark-stringify": "^11.0.0",
+    "shiki": "^4.5.0",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0",
+    "web-tree-sitter": "^0.27.0",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@g3nomaly/ui": "^0.3.1",
+    "@tanstack/react-router": "^1.170.41",
+    "@tanstack/react-store": "^0.11.2",
+    "@tree-sitter-grammars/tree-sitter-kotlin": "^1.1.0",
+    "@types/bun": "^1.4.2",
+    "@types/d3-drag": "^3.0.7",
+    "@types/d3-force": "^3.0.10",
+    "@types/d3-selection": "^3.0.12",
+    "@types/d3-zoom": "^3.0.9",
+    "@types/hast": "^3.0.5",
+    "@types/mdast": "^4.0.4",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vscode/tree-sitter-wasm": "^0.3.1",
+    "bun-plugin-tailwind": "^0.1.2",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "d3-drag": "^3.0.0",
+    "d3-force": "^3.0.0",
+    "d3-selection": "^3.0.0",
+    "d3-zoom": "^3.0.0",
+    "lucide-react": "^1.52.0",
+    "radix-ui": "^1.7.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "shadcn": "^4.21.3",
+    "tailwind-merge": "^3.7.0",
+    "tailwindcss": "^4.3.3",
+    "tree-sitter-c": "^0.24.1",
+    "tree-sitter-scala": "^0.24.0",
+    "tw-animate-css": "^1.4.0",
+    "typescript": "^7.0.2"
+  },
+  "license": "Elastic-2.0",
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  }
+}