208 lines
8.6 KiB
C++
208 lines
8.6 KiB
C++
#pragma once
|
|
#include <string>
|
|
#include <vector>
|
|
#include <sstream>
|
|
|
|
class APIDocGenerator {
|
|
public:
|
|
struct APIEntry {
|
|
std::string component;
|
|
std::string category; // "parser", "generator", "validator", "optimizer", "editor", "api"
|
|
std::string description;
|
|
std::vector<std::string> methods;
|
|
};
|
|
|
|
std::vector<APIEntry> getAPIEntries() const {
|
|
return {
|
|
// Parsers
|
|
{"TreeSitterParser", "parser",
|
|
"Parses source code (Python, C++, Elisp, JavaScript, TypeScript, Java, Rust, Go) into Whetstone AST using tree-sitter grammars",
|
|
{"parsePython(source)", "parsePythonWithDiagnostics(source)",
|
|
"parseCpp(source)", "parseCppWithDiagnostics(source)",
|
|
"parseElisp(source)", "parseElispWithDiagnostics(source)",
|
|
"parseJavaScript(source)", "parseJavaScriptWithDiagnostics(source)",
|
|
"parseTypeScript(source)", "parseTypeScriptWithDiagnostics(source)",
|
|
"parseJava(source)", "parseJavaWithDiagnostics(source)",
|
|
"parseRust(source)", "parseRustWithDiagnostics(source)",
|
|
"parseGo(source)", "parseGoWithDiagnostics(source)"}},
|
|
|
|
// Generators
|
|
{"PythonGenerator", "generator",
|
|
"Generates Python source code from Whetstone AST",
|
|
{"generate(node)"}},
|
|
|
|
{"CppGenerator", "generator",
|
|
"Generates C++ source code from Whetstone AST with memory annotation support",
|
|
{"generate(node)"}},
|
|
|
|
{"ElispGenerator", "generator",
|
|
"Generates Emacs Lisp source code from Whetstone AST",
|
|
{"generate(node)"}},
|
|
|
|
{"JavaScriptGenerator", "generator",
|
|
"Generates JavaScript source code from Whetstone AST",
|
|
{"generate(node)"}},
|
|
|
|
{"TypeScriptGenerator", "generator",
|
|
"Generates TypeScript source code from Whetstone AST with type annotations",
|
|
{"generate(node)"}},
|
|
|
|
{"JavaGenerator", "generator",
|
|
"Generates Java source code from Whetstone AST",
|
|
{"generate(node)"}},
|
|
|
|
{"RustGenerator", "generator",
|
|
"Generates Rust source code from Whetstone AST",
|
|
{"generate(node)"}},
|
|
|
|
{"GoGenerator", "generator",
|
|
"Generates Go source code from Whetstone AST",
|
|
{"generate(node)"}},
|
|
|
|
// Validators
|
|
{"AnnotationValidator", "validator",
|
|
"Validates memory annotations for correctness: missing intent, aliasing, conflicts",
|
|
{"validate(root)"}},
|
|
|
|
{"StrategyValidator", "validator",
|
|
"Post-optimization invariant checking: use-after-free, leak, aliasing, destructor reachability",
|
|
{"validateInvariants(root)"}},
|
|
|
|
// Optimizers
|
|
{"TransformEngine", "optimizer",
|
|
"AST transformation engine with constant folding and dead code elimination",
|
|
{"setRoot(root)", "constantFolding()", "deadCodeElimination()", "applyAll()"}},
|
|
|
|
{"StrategyAwareOptimizer", "optimizer",
|
|
"Annotation-constrained optimization respecting memory strategy rules",
|
|
{"setRoot(root)", "inlineVariable(id)", "reorderStatements(id)",
|
|
"duplicateNode(id)", "optimizeFunction(id)"}},
|
|
|
|
{"IncrementalOptimizer", "optimizer",
|
|
"Incremental transforms with journal tracking, undo support, and provenance",
|
|
{"setRoot(root)", "applyTransform(name)", "getTransformHistory()",
|
|
"undoTransform(id)", "undoLast()", "getProvenance(nodeId)"}},
|
|
|
|
// Analysis
|
|
{"MemoryStrategyInference", "analysis",
|
|
"Infers appropriate memory annotations from language and usage patterns",
|
|
{"inferAnnotations(root)"}},
|
|
|
|
{"CrossLanguageProjector", "analysis",
|
|
"Deep-copies AST with language change and annotation adaptation",
|
|
{"project(source, targetLanguage)", "annotationsPreserved(original, projected)"}},
|
|
|
|
{"ContextAPI", "api",
|
|
"Scope analysis, call hierarchy, and data-flow dependency graph",
|
|
{"getInScopeSymbols(nodeId)", "getCallHierarchy(functionId)",
|
|
"getDependencyGraph(functionId)"}},
|
|
|
|
// Mutation APIs
|
|
{"ASTMutationAPI", "api",
|
|
"AST mutation with OptimizationLock checking and journal recording",
|
|
{"setProperty(nodeId, key, value)", "updateNode(nodeId, properties)",
|
|
"deleteNode(nodeId)", "insertNode(parentId, role, node)"}},
|
|
|
|
{"BatchMutationAPI", "api",
|
|
"Atomic batch mutations with reverse-order rollback on failure",
|
|
{"applySequence(mutations)"}},
|
|
|
|
// Editor components
|
|
{"TextEditor", "editor",
|
|
"Classical text editor with undo/redo, find/replace, and selection",
|
|
{"insertText(text)", "deleteRange(start, end)", "undo()", "redo()",
|
|
"find(query)", "replace(query, replacement)", "getSelection()"}},
|
|
|
|
{"TextASTSync", "editor",
|
|
"Bidirectional text-to-AST synchronization with debounce",
|
|
{"syncTextToAST(text)", "syncASTToText(ast)", "setDebounceMs(ms)"}},
|
|
|
|
{"SyntaxHighlighter", "editor",
|
|
"Tree-sitter CST walk producing colored token spans for Python, C++, and Elisp",
|
|
{"highlight(source, language)"}},
|
|
|
|
{"KeybindingManager", "editor",
|
|
"Configurable keybinding profiles: VSCode (default), JetBrains, Emacs",
|
|
{"setProfile(profile)", "getBinding(action)", "setCustomBinding(action, combo)"}},
|
|
|
|
{"BufferManager", "editor",
|
|
"Multi-buffer management for open/close/switch operations",
|
|
{"openBuffer(path)", "closeBuffer(id)", "switchBuffer(id)",
|
|
"getActiveBuffer()", "listBuffers()"}},
|
|
|
|
{"EditorMode", "editor",
|
|
"Per-language editing behavior: indentation, comments, brackets, snippets",
|
|
{"setLanguage(language)", "getIndentRule()", "getCommentStyle()",
|
|
"getBracketPairs()", "getSnippets()"}},
|
|
|
|
// Infrastructure
|
|
{"Pipeline", "infrastructure",
|
|
"End-to-end pipeline: parse → infer → validate → optimize → generate",
|
|
{"run(source, sourceLanguage, targetLanguage)", "parse(source, language)",
|
|
"generate(ast, language)"}},
|
|
|
|
{"WebSocketAgentServer", "infrastructure",
|
|
"WebSocket endpoint for external agent integration with JSON-RPC routing",
|
|
{"start(port)", "registerHandler(method, handler)",
|
|
"listSessions()", "getSessionInfo(id)"}},
|
|
|
|
{"ASTSchema", "infrastructure",
|
|
"AST schema validation against concept rules",
|
|
{"validate(node)", "addRule(conceptType, rule)"}},
|
|
};
|
|
}
|
|
|
|
std::string generateMarkdown() const {
|
|
std::ostringstream out;
|
|
auto entries = getAPIEntries();
|
|
|
|
out << "# Whetstone DSL API Reference\n\n";
|
|
out << "**Components:** " << entries.size() << "\n\n";
|
|
|
|
std::string currentCategory;
|
|
for (const auto& entry : entries) {
|
|
if (entry.category != currentCategory) {
|
|
currentCategory = entry.category;
|
|
out << "## " << capitalize(currentCategory) << "\n\n";
|
|
}
|
|
|
|
out << "### " << entry.component << "\n\n";
|
|
out << entry.description << "\n\n";
|
|
out << "**Methods:**\n";
|
|
for (const auto& method : entry.methods) {
|
|
out << "- `" << method << "`\n";
|
|
}
|
|
out << "\n";
|
|
}
|
|
|
|
return out.str();
|
|
}
|
|
|
|
// Verify that all major API categories are covered
|
|
bool verifyCoverage() const {
|
|
auto entries = getAPIEntries();
|
|
bool hasParser = false, hasGenerator = false, hasValidator = false;
|
|
bool hasOptimizer = false, hasEditor = false, hasAPI = false;
|
|
|
|
for (const auto& e : entries) {
|
|
if (e.category == "parser") hasParser = true;
|
|
if (e.category == "generator") hasGenerator = true;
|
|
if (e.category == "validator") hasValidator = true;
|
|
if (e.category == "optimizer") hasOptimizer = true;
|
|
if (e.category == "editor") hasEditor = true;
|
|
if (e.category == "api") hasAPI = true;
|
|
}
|
|
|
|
return hasParser && hasGenerator && hasValidator &&
|
|
hasOptimizer && hasEditor && hasAPI;
|
|
}
|
|
|
|
private:
|
|
static std::string capitalize(const std::string& s) {
|
|
if (s.empty()) return s;
|
|
std::string result = s;
|
|
result[0] = static_cast<char>(std::toupper(result[0]));
|
|
return result;
|
|
}
|
|
};
|