text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
import { describe, it, expect } from "vitest";
import {
buildLanguageLessonPrompt,
parseLanguageLessonResponse,
detectLanguageConcepts,
} from "../analyzer/language-lesson.js";
import type { GraphNode, GraphEdge } from "../types.js";
import { typescriptConfig } from "../languages/configs/typescript.js";
const sa... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect } from "vitest";
import { LanguageRegistry } from "../languages/language-registry.js";
import { StrictLanguageConfigSchema } from "../languages/types.js";
import { typescriptConfig } from "../languages/configs/typescript.js";
import { pythonConfig } from "../languages/configs... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect } from "vitest";
import {
detectLayers,
buildLayerDetectionPrompt,
parseLayerDetectionResponse,
applyLLMLay<|fim_suffix|>raph);
const apiLayer = layers.find((l) => l.name === "API Layer");
expect(apiLayer).toBeDefined();
expect(apiLayer!.nodeIds).toContain... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>lePath: "src/bare.ts",
summary: "Bare",
tags: [],
complexity: "simple",
},
{
id: "file:src/target.ts",
type: "file",
name: "target.ts",
filePath: "src/target.ts",
summary: "Target",
tags: [],
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect } from "vitest";
import { MarkdownParser } from "../plugins/parsers/markdown-parser.js";
import { YAMLConfigParser } from "../plugins/parsers/yaml-parser.js";
import { JSONConfigParser, stripJsoncSyntax } from "../plugins/parsers/json-parser.js";
import { TOMLParser } from ".... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>impo<|fim_suffix|>const json = serializePluginConfig(config);
expect(json).toContain('"options"');
expect(json).toContain('"strict": true');
});
});
});
<|fim_middle|>rt { describe, it, expect } from "vitest";
import {
parsePluginConfig,
serializePluginConfig,
type PluginConfig,
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect } from "vitest";
import { PluginRegistry } from "../plugins/registry.js";
import { registerAllParsers } from "../plugins/parsers/index.js";
import type { AnalyzerPlugin, StructuralAnalysis, ImportResolution } from "../types.js";
const emptyAnalysis: StructuralAnalysis = {
... | fim | Egonex-AI/Understand-Anything | typescript |
import { describe, it, expect } from "vitest";
import {
validateGraph,
sanitizeGraph,
autoFixGraph,
NODE_TYPE_ALIASES,
EDGE_TYPE_ALIASES,
} from "../schema.js";
import type { KnowledgeGraph } from "../types.js";
const validGraph: KnowledgeGraph = {
version: "1.0.0",
project: {
name: "test-project",
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect } from "vitest";
import { SearchEngine } from "../search.js";
import type { GraphNode } from "../types.js";
const makeNode = (overrides: Partial<GraphNode> & { id: string; name: string }): GraphNode => ({
type: "file",
summary: "",
tags: [],
complexity: "simple",
.... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect, vi, beforeEach } from "vitest";
import type { KnowledgeGraph, GraphNode, GraphEdge } from "../types.js";
vi.mock("child_process", () => ({
execFileSync: vi.fn(),
}));
// Import after mocking
import { execFileSync } from "child_process";
import { getChangedFiles, isStale,... | fim | Egonex-AI/Understand-Anything | typescript |
import { describe, it, expect } from "vitest";
import {
buildTourGenerationPrompt,
parseTourGenerationResponse,
generateHeuristicTour,
} from "../analyzer/tour-generator.js";
import type { KnowledgeGraph } from "../types.js";
const sampleGraph: KnowledgeGraph = {
version: "1.0.0",
project: {
name: "test-... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>Manages stored data");
});
it("should create contains edges between files and their functions/classes", () => {
const builder = new GraphBuilder("test-project", "abc123");
const analysis: StructuralAnalysis = {
functions: [
{ name: "helper", lineRange: [5, 15], params: [] },
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ary: `Endpoint: ${name}`,
tags: [],
complexity: meta.complexity,
}, fileId);
}
// Create child nodes for steps (pipeline/makefile targets)
for (const step of meta.steps ?? []) {
this.addChildNode({
id: `step:${filePath}:${step.name}`,
type: "pipelin... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ds.some((keyword) =>
text.toLowerCase().includes(keyword.toLowerCase()),
);
if (found) {
detected.push(concept);
}
}
return detected;
}
/**
* Get the display name for a language.
* Uses LanguageConfig if provided, otherwise falls back to capitalization.
*/
export function ... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> name)?.description ?? "";
layers.push({
id: toLayerId(name),
name,
description,
nodeIds,
});
}
return layers;
}
/**
* Builds an LLM prompt that asks the model to identify logical layers
* from a list of file paths in the knowledge graph.
*/
export function buildL... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>!.description).toBe("A CLI tool");
expect(result!.frameworks).toEqual(["Commander"]);
});
it("should return null for invalid JSON", () => {
const result = parseProjectSummaryResponse("Not valid JSON");
expect(result).toBeNull();
});
it("should handle missing fields grac... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>export interface LLMFileAnalysis {
fileSummary: string;
tags: string[];
complexity: "simple" | "moderate" | "complex";
functionSummaries: Record<string, string>;
classSummaries: Record<string, string>;
languageNotes?: string;
}
export interface LLMProjectSummary {
description: string;
fra... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>(value) && value >= 1) {
if (value <= 3) return "simple";
if (value <= 6) return "moderate";
return "complex";
}
return "moderate";
}
export interface DroppedEdge {
source: string;
target: string;
type: string;
reason: "missing-source" | "missing-target" | "missing-both";
}
expo... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { KnowledgeGraph, TourStep } from "../types.js";
/**
* Builds an LLM prompt asking for a guided tour of the project.
* Includes project metadata, node summaries, edges, and layer info.
*/
export function buildTourGenerationPrompt(graph: KnowledgeGraph): string {
const { project, nodes, e... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { dirname } from "node:path";
import type { ChangeAnalysis } from "./fingerprint.js";
export interface UpdateDecision {
action: "SKIP" | "PARTIAL_UPDATE" | "ARCHITECTURE_UPDATE" | "FULL_UPDATE";
filesToReanalyze: string[];
rerunArchitecture: boolean;
rerunTour: boolean;
reason: string;
}... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> updateNodes(nodes: GraphNode[]): void {
this.nodes = nodes;
}
}
<|fim_prefix|>import type { GraphNode } from "./types.js";
import type { SearchResult } from "./search.js";
export interface SemanticSearchOptions {
limit?: number;
threshold?: number;
types?: string[];
}
/**
* Compute cosine... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> details: ["file deleted"],
});
}
continue;
}
// File is new
if (!existedBefore) {
newFiles.push(filePath);
fileChanges.push({
filePath,
changeLevel: "STRUCTURAL",
details: ["new file"],
});
continue;
}
// File ex... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import ignore, { type Ignore } from "ignore";
import { readFileSync, existsSync } from "node:fs";
import { join } from "node:path";
/**
* Hardcoded default ignore patterns matching the project-scanner agent's
* exclusion rules, plus bin<|fim_suffix|> from .understandignore files.
*
* Pattern load ord... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { existsSync, readFileSync } from "node:fs";
import { join } from "node:path";
import { DEFAULT_IGNORE_PATTERNS } from "./ignore-filter.js";
const HEADER = `# .understandignore — patterns for files/dirs to exclude from analysis
# Syntax: same as .gitignore (globs, # comments, ! negation, trailing ... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>export * from "./types.js";
export * from "./p<|fim_suffix|>ALIASES,
type ValidationResult,
type GraphIssue,
} from "./schema.js";
export { TreeSitterPlugin } from "./plugins/tree-sitter-plugin.js";
export type { LanguageExtractor } from "./plugins/extractors/types.js";
export { builtinExtractors } fr... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const batchConfig = {
id: "batch",
displayName: "Batch Script",
extensions: [".bat", ".cmd"],
concepts: ["commands", "variable<|fim_suffix|>s: [],
tests: [],
config: [],
},
} satisfies LanguageConfig;
<|fim_middle|>s", "labels", ... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>t.c", "test_*.c"],
config: ["Makefile", "CMakeLists.txt", "meson.build"],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const cConfig = {
id: "c",
displayName: "C",
extensions: [".c", ".h"],
treeSitter: {
wasmPackage: "tree-sitter... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>tisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const cppConfig = {
id: "cpp",
displayName: "C++",
extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hxx"],
treeSitter: {
wasmPackage: "tree-sitter-cpp",
wasmFile: "tree-sitter-cpp.wasm",
},
co... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>
barrels: [],
tests: ["*Tests.cs", "*Test.cs"],
config: ["*.csproj", "*.sln"],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const csharpConfig = {
id: "csharp",
displayName: "C#",
extensions: [".cs"],
treeSitter: {
wasmPa... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ons", "specificity"],
filePatterns: {
entryPoints: [],
barrels: [],
tests: [],
config: [],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { Lang<|fim_middle|>uageConfig } from "../types.js";
export const cssConfig = {
id: "css",
displayName: "CSS",
extensions: [".css",... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const csvConfig = {
id: "csv",
displayName: "CSV",
extensions: [".csv", ".tsv"],
concepts: ["headers", "rows", <|fim_suffix|>: [],
config: [],
},
} satisfies LanguageConfig;
<|fim_middle|>"delimiters", "quoting", "escaping"],
fileP... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> config: [],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const dockerComposeConfig = {
id: "docker-compose",
displayName: "Docker Compose",
extensions: [],
filenames: ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { Language<|fim_suffix|>;
export const dockerfileConfig = {
id: "dockerfile",
displayName: "Dockerfile",
extensions: [],
filenames: ["Dockerfile", "Dockerfile.dev", "Dockerfile.prod", "Dockerfile.test"],
concepts: ["multi-stage builds", "layers", "base images", "COPY/ADD", "EXPOSE",... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import typ<|fim_suffix|>onfig } from "../types.js";
export const envConfig = {
id: "env",
displayName: "Environment Variables",
extensions: [".env"],
filenames: [".env", ".env.local", ".env.development", ".env.production", ".env.test", ".env.example"],
concepts: ["key-value pairs", "variable in... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const githubActionsConfig = {
<|fim_middle|> id: "github-actions",
displayName: "GitHub Actions",
extensions: [],
concepts: ["workflows", "jobs", "steps", "actions", "triggers", "secrets", "matrix strategy", "artifacts"],
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>
config: ["go.mod", "go.sum"],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const goConfig = {
id: "go",
displayName: "Go",
extensions: [".go"],
treeSitter: {
wasmPackage: "tree-sitter-go",
wasmFile: "tree-sitter-go.wasm",
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const graphqlConfig = {
id: "graphql",
displayName: "GraphQL",
extensions: [".graphql", ".gql"],
concepts: ["types", "queries", "mutations", "subscriptions", "resolvers", "directives", "fragments", "schema"],
filePatter<|fim_suffix|>ntry... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>oncepts: ["elements", "attributes", "semantic tags", "forms", "meta tags", "scripts", "stylesheets", "accessibility"],
filePatterns: {
entryPoints: ["index.html"],
barrels: [],
tests: [],
config: [],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from ".<|f... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>fig,
cppConfig,
csharpConfig,
// Non-code languages
markdownConfig,
yamlConfig,
jsonConfigConfig,
tomlConfig,
envConfig,
xmlConfig,
dockerfileConfig,
sqlConfig,
graphqlConfig,
protobufConfig,
terraformConfig,
githubActionsConfig,
makefileConfig,
shellConfig,
htmlConfig,... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> "**/Main.java",
"src/main/java/**/App.java",
],
barrels: [],
tests: ["*Test.java", "*Tests.java", "*IT.java"],
config: ["pom.xml", "build.gradle", "build.gradle.kts"],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const ... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const javascriptConfig = {
id: "javascript",
displayName: "JavaScript",
extensions: [".js", ".jsx", ".mjs", ".cjs<|fim_suffix|> tests: ["*.test.js", "*.spec.js"],
config: ["package.json", "jsconfig.json"],
},
} satisfies LanguageConfi... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const jenkinsfileConfig = {
id: "jenkinsfile",
displayName: "Jenkinsfile",
extensions: [],
filenames: ["Jenkinsfile"],
concepts: ["pipeline", "stages", "steps", "agents", "environ<|fim_suffix|>geConfig;
<|fim_middle|>ment", "post actions... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } <|fim_suffix|>extensions: [".json", ".jsonc"],
concepts: ["objects", "arrays", "nesting", "schema references", "comments (JSONC)"],
filePatterns: {
entryPoints: ["package.json"],
barrels: [],
tests: [],
config: ["tsconfig.json", "package.json", ".eslintrc... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
// TODO: JSON Schema files have no unique extension — *.schema.json files will match
// `jsonConfigConfig` by the `.json` extension. Detection requires content-based
// heuristics <|fim_suffix|>tterns: {
entryPoints: [],
barrels: [],
tests: [... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const kotlinConfig = {
id: "kotlin",
displayName: "Kotlin",
extensions: [".kt", ".kts"],
treeSitter: {
wasmPackage: "@tree-sitter-grammars/tree-sitter-kotlin",
wasmFile: "tree-sitter-kotlin.wasm",
},
concepts: [
"coroutines... | fim | Egonex-AI/Understand-Anything | typescript |
import type { LanguageConfig } from "../types.js";
// TODO: Kubernetes manifests are YAML files with no unique extension or filename.
// Detection requires content-based or path-pattern heuristics (e.g., checking for
// `apiVersion`/`kind` fields in YAML, or matching paths like `k8s/`, `kubernetes/`,
// `deploy/`). Cu... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const luaConfig = {
id: "lua",
displayName: "Lua",
extensions: [".lua"],
concepts: [
"tables",
"metatables",
"coroutines",
"closures",
"prototype-based OOP",
"varargs",
"weak references",
"environments",
]... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>: ["Makefile", "GNUmakefile", "makefile"],
concepts: ["targets", "dependencies", "recipes", "variables", "pattern rules", "phony targets", "includes"],
filePatterns: {
entryPoints: ["Makefile"],
barrels: [],
tests: [],
config: [],
},
} satisfies LanguageConfig;
<|fim_prefix|>import t... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>onfig: [],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const markdownConfig = {
id: "markdown",
displayName: "Markdown",
extensions: [".md", ".mdx"],
concepts: ["headings", "links", "code blocks", "front matter", "lists", "tables", "ima... | fim | Egonex-AI/Understand-Anything | typescript |
import type { LanguageConfig } from "../types.js";
export const openapiConfig = {
id: "openapi",
displayName: "OpenAPI",
extensions: [],
filenames: ["openapi.yaml", "openapi.json", "swagger.yaml", "swagger.json"],
concepts: ["paths", "operations", "schemas", "parameters", "responses", "security schemes", "ta... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const phpConfig = {
id: "php",
displayName: "PHP",
extensions: [".php"],
treeSitter: {
wasmPackage: "tree-sitter-php",
wasmFile: "tree-sitter-php.wasm",
},
concepts: [<|fim_suffix|>es",
"enums",
"fibers",
"closures"... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>t", ".text"],
concepts: ["paragraphs", "lists", "sections"],
filePatterns: {
entryPoints: [],
barrels: [],
tests: [],
config: [],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const plaintextConfig = <|fim_middle|>{
id: "pla... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ets", "pipelines", "modules", "functions", "parameters", "variables", "error handling"],
filePatterns: {
entryPoints: [],
barrels: [],
tests: [],
config: [],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const powershellConfig =... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const protobufConfig = {
id: "protobuf",
displayName: "Protocol Buffers",
extensions: [".proto"],
concepts: ["messages", "services", "enums"<|fim_suffix|>, "imports"],
filePatterns: {
entryPoints: [],
barrels: [],
tests: [],
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const pythonConfig = {
id: "python",
displayName: "Python",
extensions: [".py", ".pyi"],
treeSitter: {
wasmPackage: "tree-sitter-python",
wasmFile: "tree-sitter-python.wasm",
},
concepts: [
"decorator<|fim_suffix|>.py"],
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const restructuredtextConfig = {
id: "restructuredtext",
displayName: "reSt<|fim_suffix|>headings", "directives", "roles", "cross-references", "toctree", "code blocks", "admonitions"],
filePatterns: {
entryPoints: ["index.rst"],
barr... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const rubyConfig = {
id: "ruby",
displayName: "Ruby",
extensions: [".rb", ".rake"],
treeSitter: {
wasmPackage: "tree-sitter-ruby",
wasmFile: "tree-sitter-ruby.wasm",
},
concepts: [
"blocks and procs",
"mixins",
"met... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const rustConfig = {
id: "rust",
displayName: "Rust",
extensions: [".rs"],
treeSitter: {
wasmPackage: "tree-sitter-rust",
wasmFile: "tree-sitter-rust.wasm",
},
concepts: [
"ownership",
"borrowing",
"lifetimes",
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>els: [],
tests: [],
config: [".bashrc", ".zshrc", ".profile"],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const shellConfig = {
id: "shell",
displayName: "Shell Script",
extensions: [".sh", ".bash", ".zsh"],
concepts: ["variabl... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const sqlConfig = {
id: "sql",
displayName: "SQL",
extensions: [".sql"],
concepts: ["tables", "columns", "indexes", "foreign k<|fim_suffix|>[],
config: [],
},
} satisfies LanguageConfig;
<|fim_middle|>eys", "views", "stored procedure... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>",
"actors",
"structured concurrency",
"value types vs reference types",
],
filePatterns: {
entryPoints: ["Sources/*/main.swift", "App.swift", "AppDelegate.swift"],
barrels: [],
tests: ["*Tests.swift", "Tests/**/*.swift"],
config: ["Package.swift"],
},
} satisfies Languag... | fim | Egonex-AI/Understand-Anything | typescript |
import type { LanguageConfig } from "../types.js";
export const terraformConfig = {
id: "terraform",
displayName: "Terraform",
extensions: [".tf", ".tfvars"],
concepts: ["resources", "data sources", "variables", "outputs", "modules", "providers", "state", "workspaces"],
filePatterns: {
entryPoints: ["mai... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>"key-value pairs", "dotted keys"],
filePatterns: {
entryPoints: [],
barrels: [],
tests: [],
config: ["Cargo.toml", "pyproject.toml", "netlify.toml"],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const tomlConfig = {
id: "toml... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const typescriptConfig = {
id: "typescript",
displayName: "TypeScript",
extensions: [".ts", ".tsx"],
treeSitter: {
wasmPackage: "tree-sitter-typescript",
wasmFile: "tree-sitter-typescript.wasm",
},
concepts: [
"generics",
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>
barrels: [],
tests: [],
config: ["pom.xml", "web.xml", "AndroidManifest.xml"],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export const xmlConfig = {
id: "xml",
di<|fim_middle|>splayName: "XML",
extensions: [".xml", ".xsl", ".xsd", ... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> entryPoints: [],
barrels: [],
tests: [],
config: ["*.yaml", "*.yml"],
},
} satisfies LanguageConfig;
<|fim_prefix|>import type { LanguageConfig } from "../types.js";
export con<|fim_middle|>st yamlConfig = {
id: "yaml",
displayName: "YAML",
extensions: [".yaml", ".yml"],
concepts:... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { FrameworkConfigSchema } from "./types.js";
import type { FrameworkConfig } from "./types.js";
import { builtinFrameworkConfigs } from "./frameworks/index.js";
/**
* Registry for framework configurations. Provides detection of frameworks
* from manifest file contents and lookup by id or languag... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { FrameworkConfig } from "../types.js";
export const djangoConfig = {
id: "django",
displayName: "Django",
languages: ["python"]<|fim_suffix|> ],
promptSnippetPath: "./frameworks/django.md",
entryPoints: ["manage.py", "wsgi.py", "asgi.py"],
layerHints: {
views: "api",
mode... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>\"express\":", "express-validator", "express-session"],
manifestFiles: ["package.json"],
promptSnippetPath: "./frameworks/express.md",
entryPoints: [
"src/index.js",
"src/app.js",
"server.js",
"app.js",
"src/index.ts",
"src/app.ts",
],
layerHints: {
routes: "api",
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>",
],
promptSnippetPath: "./frameworks/fastapi.md",
entryPoints: ["main.py", "app.py"],
layerHints: {
routers: "api",
schemas: "types",
models: "data",
dependencies: "service",
crud: "service",
api: "api",
},
} satisfies FrameworkConfig;
<|fim_prefix|>import type { Framew... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>onKeywords: [
"flask",
"flask-restful",
"flask-sqlalchemy",
"flask-marshmallow",
"flask-wtf",
],
manifestFiles: [
"requirements.txt",
"pyproject.toml",
"setup.py",
"setup.cfg",
"Pipfile",
],
promptSnippetPath: "./frameworks/flask.md",
entryPoints: ["app.py... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { FrameworkConfig } from "../types.js";
export const ginConfig = {
id: "gin",
displayName: "Gin",
languages: ["go"],
detectionKeywords: ["github.com/gin-gonic/gin"]<|fim_suffix|>vice",
repository: "data",
},
} satisfies FrameworkConfig;
<|fim_middle|>,
manifestFiles: ["go.mod"... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { FrameworkConfig } from "../types.js";
import { djangoConfig } from "./django.js";
import { fastapiConfig } from "./fastapi.js";
import { flaskConfig } from "./flask.js";
import { reactConfig } from "./react.js";
import { nextjsConfig } from "./nextjs.js";
import { expressConfig } from "./ex... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>petPath: "./frameworks/nextjs.md",
entryPoints: [
"src/app/layout.tsx",
"pages/_app.tsx",
"src/pages/_app.tsx",
],
layerHints: {
app: "ui",
pages: "ui",
api: "api",
components: "ui",
lib: "service",
middleware: "middleware",
},
} satisfies FrameworkConfig;
<|fim... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> channels: "service",
middleware: "middleware",
lib: "service",
},
} satisfies FrameworkConfig;
<|fim_prefix|>import type { FrameworkConfig } from "../types.js";
export const railsConfig = {
id: "rails",
displayName: "Ruby on Rails",
languages: ["ruby"],
detectionKeywords: [
"rails... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>
entryPoints: ["src/App.tsx", "src/App.jsx", "src/index.tsx", "src/main.tsx"],
layerHints: {
components: "ui",
hooks: "service",
pages: "ui",
contexts: "service",
utils: "utility",
lib: "service",
},
} satisfies FrameworkConfig;
<|fim_prefix|>import type { FrameworkConfig } f... | fim | Egonex-AI/Understand-Anything | typescript |
import type { FrameworkConfig } from "../types.js";
export const springConfig = {
id: "spring",
displayName: "Spring Boot",
languages: ["java", "kotlin"],
detectionKeywords: [
"spring-boot",
"spring-boot-starter",
"spring-web",
"spring-data",
"org.springframework",
],
manifestFiles: ["p... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>c/main.js"],
layerHints: {
components: "ui",
views: "ui",
store: "service",
composables: "service",
router: "config",
plugins: "config",
},
} satisfies FrameworkConfig;
<|fim_prefix|>import type { FrameworkConfig } from "../types.js";
export const vueConfig = {
id: "vue",
... | fim | Egonex-AI/Understand-Anything | typescript |
// Types
export type {
LanguageConfig,
TreeSitterConfig,
FilePatternConfig,
FrameworkConfig,
} from "./types.js";
export {
LanguageConfigSchema,
TreeSitterConfigSchema,
FilePatternConfigSchema,
FrameworkConfigSchema,
} from "./types.js";
// Registries
export { LanguageRegistry } from "./language-regis... | fim | Egonex-AI/Understand-Anything | typescript |
import { LanguageConfigSchema } from "./types.js";
import type { LanguageConfig } from "./types.js";
import { builtinLanguageConfigs } from "./configs/index.js";
/**
* Registry for language configurations. Maps language ids and file extensions
* to their corresponding LanguageConfig objects.
*/
export class Languag... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ptSnippetPath: z.string().min(1),
entryPoints: z.array(z.string()).optional(),
layerHints: z.record(z.string(), z.string()).optional(),
});
export type FrameworkConfig = z.infer<typeof FrameworkConfigSchema>;
<|fim_prefix|>import { z } from "zod";
// Tree-sitter grammar configuration for a language.... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>AnalysisMeta;
}
export function saveFingerprints(projectRoot: string, store: FingerprintStore): void {
const dir = ensureDir(projectRoot);
writeFileSync(join(dir, FINGERPRINT_FILE), JSON.stringify(store, null, 2), "utf-8");
}
export function loadFingerprints(projectRoot: string): FingerprintStore | ... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>mitHash: "abc123",
version: "1.0.0",
analyzedFiles: 42,
};
describe("saveGraph / loadGraph", () => {
it("should write knowledge-graph.json to .understand-anything/", () => {
saveGraph(tempDir, sampleGraph);
const filePath = join(tempDir, ".understand-anything", "knowledge-gra... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { builtinLanguageConfigs } from "../languages/configs/index.js";
export interface PluginEntry {
name: string;
enabled: boolean;
languages: string[];
options?: Record<string, unknown>;
}
export interface PluginConfig {
plugins: PluginEntry[];
}
export const DEFAULT_PLUGIN_CONFIG: Plugin... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect, beforeAll } from "vitest";
import { createRequire } from "node:module";
import { CppExtractor } from "../cpp-extractor.js";
const require = createRequire(import.meta.url);
// Load tree-sitter + C++ grammar once
let Parser: any;
let Language: any;
let cppLang: any;
beforeA... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ame).sort()).toEqual(
["GetUsers", "Log", "UserService"].sort(),
);
// Constructor has params but no return type
const ctor = result.functions.find((f) => f.name === "UserService");
expect(ctor?.params).toEqual(["name"]);
expect(ctor?.returnType).toBeUndefined();
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> const { tree, parser, root } = parse(`package main
type Point struct {
X, Y int
Z float64
}
`);
const result = extractor.extractStructure(root);
expect(result.classes).toHaveLength(1);
expect(result.classes[0].properties).toContain("X");
expect(result.classes[0].... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect, beforeAll } from "vitest";
import { createRequire } from "node:module";
import { JavaExtractor } from "../java-extractor.js";
const require = createRequire(import.meta.url);
// Load tree-sitter + Java grammar once
let Parser: any;
let Language: any;
let javaLang: any;
bef... | fim | Egonex-AI/Understand-Anything | typescript |
import { describe, it, expect, beforeAll } from "vitest";
import { createRequire } from "node:module";
import { KotlinExtractor } from "../kotlin-extractor.js";
const require = createRequire(import.meta.url);
let Parser: any;
let Language: any;
let kotlinLang: any;
beforeAll(async () => {
const mod = await import(... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>r.delete();
});
it("extracts instance method calls ($this->method())", () => {
const { tree, parser, root } = parse(`<?php
class Svc {
public function getUser(int $id): User {
return $this->fetchFromDb($id);
}
}
`);
const result = extractor.extractCallGraph(root);
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect, beforeAll } from "vitest";
import { createRequire } from "node:module";
import { PythonExtractor } from "../python-extractor.js";
const require = createRequire(import.meta.url);
// Load tree-sitter + Python grammar once
let Parser: any;
let Language: any;
let pythonLang: a... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect, beforeAll } from "vitest";
import { createRequire } from "node:module";
import { RubyExtractor } from "../ruby-extractor.js";
const require = createRequire(import.meta.url);
// Load tree-sitter + Ruby grammar once
let Parser: any;
let Language: any;
let rubyLang: any;
bef... | fim | Egonex-AI/Understand-Anything | typescript |
import { describe, it, expect, beforeAll } from "vitest";
import { createRequire } from "node:module";
import { RustExtractor } from "../rust-extractor.js";
const require = createRequire(import.meta.url);
// Load tree-sitter + Rust grammar once
let Parser: any;
let Language: any;
let rustLang: any;
beforeAll(async (... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { TreeSit<|fim_suffix|>: TreeSitterNode[] = [];
for (let i = 0; i < node.childCount; i++) {
const child = node.child(i);
if (child && child.type === type) result.push(child);
}
return result;
}
/** Check if a node has a child of the given type (used for export/visibility checks)... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import type { StructuralAnalysis, CallGraphEntry } from "../../types.js";
import type { LanguageExtractor, TreeSitterNode } from "./types.js";
import { findChild, findChildren } from "./base-extractor.js";
/**
* Recursively unwrap nested declarators (pointer_declarator, reference_declarator,
* array_de... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>lineRange: [
node.startPosition.row + 1,
node.endPosition.row + 1,
],
methods,
properties,
});
if (hasModifier(node, "public")) {
exports.push({
name: nameNode.text,
lineNumber: node.startPosition.row + 1,
});
}
}
/**
* Ext... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>sNode ?? null);
const returnType = extractResultType(node);
functions.push({
name: nameNode.text,
lineRange: [
node.startPosition.row + 1,
node.endPosition.row + 1,
],
params,
returnType,
});
// Track receiver type for struct association
... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>
new RubyExtractor(),
new PhpExtractor(),
new CppExtractor(),
new CSharpExtractor(),
new KotlinExtractor(),
];
<|fim_prefix|>export type { LanguageExtractor, TreeSitterNode } from "./types.js";
export { traverse, getStringValue, findChild, findChildren, hasChildOfType } from "./base-extractor.js... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ode.startPosition.row + 1,
node.endPosition.row + 1,
],
params,
// Constructors have no return type
});
if (hasModifier(node, "public")) {
exports.push({
name: nameNode.text,
lineNumber: node.startPosition.row + 1,
});
}
}
private ext... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>d prefix). The alias
* appears as `as` + a top-level `identifier` sibling.
*/
private extractImport(
declNode: TreeSitterNode,
imports: StructuralAnalysis["imports"],
): void {
const qualified = findChild(declNode, "qualified_identifier");
if (!qualified) return;
const parts... | fim | Egonex-AI/Understand-Anything | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.