Egonex-AI/Understand-Anything / understand-anything-plugin/skills/understand
understand
VerifiedAnalyze a codebase to produce an interactive knowledge graph for understanding architecture, components, and relationships
extract-structure-result.mjs
View on GitHub// Pure result mapping for extract-structure.mjs.
// Kept separate from the CLI entrypoint so unit tests do not import a shebang script.
const REQUIRED_STRUCTURE_ARRAY_FIELDS = [
'functions',
'classes',
'imports',
'exports',
];
const OPTIONAL_STRUCTURE_ARRAY_FIELDS = [
'sections',
'definitions',
'services',
'endpoints',
'steps',
'resources',
];
function isPlainObject(value) {
if (value === null || typeof value !== 'object' || Array.isArray(value)) {
return false;
}
const prototype = Object.getPrototypeOf(value);
return prototype === Object.prototype || prototype === null;
}
function isStringArray(value) {
return Array.isArray(value) && value.every(item => typeof item === 'string');
}
function isFiniteInteger(value) {
return typeof value === 'number' &&
Number.isFinite(value) &&
Number.isInteger(value);
}
function isLineRange(value) {
return Array.isArray(value) &&
value.length === 2 &&
value.every(isFiniteInteger);
}
function hasValidOptionalField(value, field, validator) {
return value[field] === undefined || validator(value[field]);
}
function isValidEntryArray(value, validator) {
return Array.isArray(value) &&
value.every(entry => isPlainObject(entry) && validator(entry));
}
const STRUCTURE_ENTRY_VALIDATORS = {
functions: entry =>
typeof entry.name === 'string' &&
isLineRange(entry.lineRange) &&
isStringArray(entry.params) &&
hasValidOptionalField(entry, 'returnType', value => typeof value === 'string'),
classes: entry =>
typeof entry.name === 'string' &&
isLineRange(entry.lineRange) &&
isStringArray(entry.methods) &&
isStringArray(entry.properties),
imports: entry =>
typeof entry.source === 'string' &&
isStringArray(entry.specifiers) &&
isFiniteInteger(entry.lineNumber),
exports: entry =>
typeof entry.name === 'string' &&
isFiniteInteger(entry.lineNumber) &&
hasValidOptionalField(entry, 'isDefault', value => typeof value === 'boolean'),
sections: entry =>
typeof entry.name === 'string' &&
isFiniteInteger(entry.level) &&
isLineRange(entry.lineRange),
definitions: entry =>
typeof entry.name === 'string' &&
typeof entry.kind === 'string' &&
isLineRange(entry.lineRange) &&
isStringArray(entry.fields),
services: entry =>
typeof entry.name === 'string' &&
hasValidOptionalField(entry, 'image', value => typeof value === 'string') &&
Array.isArray(entry.ports) &&
entry.ports.every(isFiniteInteger) &&
hasValidOptionalField(entry, 'lineRange', isLineRange),
endpoints: entry =>
hasValidOptionalField(entry, 'method', value => typeof value === 'string') &&
typeof entry.path === 'string' &&
isLineRange(entry.lineRange),
steps: entry =>
typeof entry.name === 'string' &&
isLineRange(entry.lineRange),
resources: entry =>
typeof entry.name === 'string' &&
typeof entry.kind === 'string' &&
isLineRange(entry.lineRange),
};
function isValidStructuralAnalysis(analysis) {
if (!isPlainObject(analysis)) {
return false;
}
return REQUIRED_STRUCTURE_ARRAY_FIELDS.every(field =>
isValidEntryArray(analysis[field], STRUCTURE_ENTRY_VALIDATORS[field])) &&
OPTIONAL_STRUCTURE_ARRAY_FIELDS.every(field =>
hasValidOptionalField(
analysis,
field,
value => isValidEntryArray(value, STRUCTURE_ENTRY_VALIDATORS[field]),
));
}
function isValidCallGraph(callGraph) {
return Array.isArray(callGraph) && callGraph.every(entry =>
isPlainObject(entry) &&
typeof entry.caller === 'string' &&
typeof entry.callee === 'string' &&
isFiniteInteger(entry.lineNumber));
}
function mapCallGraph(callGraph) {
return callGraph && callGraph.length > 0
? callGraph.map(entry => ({
caller: entry.caller,
callee: entry.callee,
lineNumber: entry.lineNumber,
}))
: null;
}
export function analyzeFileWithOutcomes(registry, file, content) {
const wantsCallGraph =
file.fileCategory === 'code' || file.fileCategory === 'script';
const selectedPlugin = typeof registry.getPluginForFile === 'function'
? registry.getPluginForFile(file.path)
: registry;
if (selectedPlugin === null) {
return {
analysis: null,
callGraph: null,
structureOutcome: 'skipped',
callGraphOutcome: 'skipped',
};
}
const supportsFullAnalysis =
typeof selectedPlugin?.analyzeFileFull === 'function';
const supportsSeparateCallGraph =
typeof selectedPlugin?.extractCallGraph === 'function';
if (wantsCallGraph && supportsFullAnalysis) {
let full;
try {
full = registry.analyzeFileFull(file.path, content);
} catch {
return {
analysis: null,
callGraph: null,
structureOutcome: 'failed',
callGraphOutcome: wantsCallGraph ? 'failed' : 'skipped',
};
}
const analysis = isValidStructuralAnalysis(full?.structure)
? full.structure
: null;
const hasValidCallGraph = wantsCallGraph && isValidCallGraph(full?.callGraph);
const callGraph = hasValidCallGraph ? mapCallGraph(full.callGraph) : null;
return {
analysis,
callGraph,
structureOutcome: analysis === null ? 'failed' : 'succeeded',
callGraphOutcome: wantsCallGraph
? hasValidCallGraph ? 'succeeded' : 'failed'
: 'skipped',
};
}
let analysis = null;
let callGraph = null;
let structureOutcome = 'failed';
let callGraphOutcome = wantsCallGraph && supportsSeparateCallGraph
? 'failed'
: 'skipped';
try {
const extractedAnalysis = registry.analyzeFile(file.path, content);
if (isValidStructuralAnalysis(extractedAnalysis)) {
analysis = extractedAnalysis;
structureOutcome = 'succeeded';
}
} catch {
analysis = null;
structureOutcome = 'failed';
}
if (wantsCallGraph && supportsSeparateCallGraph) {
try {
const extractedCallGraph = registry.extractCallGraph(file.path, content);
if (isValidCallGraph(extractedCallGraph)) {
callGraph = mapCallGraph(extractedCallGraph);
callGraphOutcome = 'succeeded';
}
} catch {
callGraph = null;
callGraphOutcome = 'failed';
}
}
return { analysis, callGraph, structureOutcome, callGraphOutcome };
}
export function buildResult(file, totalLines, nonEmptyLines, analysis, callGraph, batchImportData) {
const base = {
path: file.path,
language: file.language,
fileCategory: file.fileCategory,
totalLines,
nonEmptyLines,
};
if (!analysis) {
base.metrics = {};
return base;
}
if (analysis.functions && analysis.functions.length > 0) {
base.functions = analysis.functions.map(fn => ({
name: fn.name,
startLine: fn.lineRange[0],
endLine: fn.lineRange[1],
params: fn.params || [],
}));
}
if (analysis.classes && analysis.classes.length > 0) {
base.classes = analysis.classes.map(cls => ({
name: cls.name,
startLine: cls.lineRange[0],
endLine: cls.lineRange[1],
methods: cls.methods || [],
properties: cls.properties || [],
}));
}
if (analysis.exports && analysis.exports.length > 0) {
base.exports = analysis.exports.map(exp => ({
name: exp.name,
line: exp.lineNumber,
isDefault: exp.isDefault === true,
}));
}
if (analysis.sections && analysis.sections.length > 0) {
base.sections = analysis.sections.map(s => ({
heading: s.name,
level: s.level,
line: s.lineRange[0],
}));
}
if (analysis.definitions && analysis.definitions.length > 0) {
base.definitions = analysis.definitions.map(d => ({
name: d.name,
kind: d.kind,
fields: d.fields || [],
startLine: d.lineRange[0],
endLine: d.lineRange[1],
}));
}
if (analysis.services && analysis.services.length > 0) {
base.services = analysis.services.map(s => ({
name: s.name,
image: s.image,
ports: s.ports || [],
...(s.lineRange ? { startLine: s.lineRange[0], endLine: s.lineRange[1] } : {}),
}));
}
if (analysis.endpoints && analysis.endpoints.length > 0) {
base.endpoints = analysis.endpoints.map(e => ({
method: e.method,
path: e.path,
startLine: e.lineRange[0],
endLine: e.lineRange[1],
}));
}
if (analysis.steps && analysis.steps.length > 0) {
base.steps = analysis.steps.map(s => ({
name: s.name,
startLine: s.lineRange[0],
endLine: s.lineRange[1],
}));
}
if (analysis.resources && analysis.resources.length > 0) {
base.resources = analysis.resources.map(r => ({
name: r.name,
kind: r.kind,
startLine: r.lineRange[0],
endLine: r.lineRange[1],
}));
}
if (callGraph && callGraph.length > 0) {
base.callGraph = callGraph;
}
const metrics = {};
const importPaths = batchImportData?.[file.path];
if (importPaths && importPaths.length > 0) {
metrics.importCount = importPaths.length;
} else if (analysis.imports) {
const internal = analysis.imports.filter(imp => {
const src = imp?.source ?? '';
return src.startsWith('.');
});
metrics.importCount = internal.length;
}
if (analysis.exports) {
metrics.exportCount = analysis.exports.length;
}
if (analysis.functions) {
metrics.functionCount = analysis.functions.length;
}
if (analysis.classes) {
metrics.classCount = analysis.classes.length;
}
if (analysis.sections) {
metrics.sectionCount = analysis.sections.length;
}
if (analysis.definitions) {
metrics.definitionCount = analysis.definitions.length;
}
if (analysis.services) {
metrics.serviceCount = analysis.services.length;
}
if (analysis.endpoints) {
metrics.endpointCount = analysis.endpoints.length;
}
if (analysis.steps) {
metrics.stepCount = analysis.steps.length;
}
if (analysis.resources) {
metrics.resourceCount = analysis.resources.length;
}
base.metrics = metrics;
return base;
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |