.

Author: codegen-bot

docs/blog/act-via-code.mdx

@@ -0,0 +1,89 @@
+---
+title: "Act via Code"
+icon: "code"
+iconType: "solid"
+description: "The path to advanced code manipulation agents"
+---
+
+The future of AI-powered software development isn't just about understanding code—it's about manipulating it effectively. As AI models become increasingly sophisticated in comprehending codebases, we're discovering that the real bottleneck isn't their "intelligence," but rather their ability to make precise, reliable changes to code. This is where the concept of "acting via code" becomes crucial.
+
+## The Current Landscape
+
+Today's AI coding assistants typically operate through:
+
+- Generating complete code snippets
+- Suggesting text-based changes
+- Producing diffs for review
+
+While these approaches work for simple tasks, they break down when dealing with complex, multi-file changes or large-scale refactors. The fundamental issue? They're trying to manipulate code as text, rather than as the structured data it really is.
+
+## Why Acting via Code Matters
+
+Acting via code means providing AI agents with programmatic interfaces to manipulate codebases. Instead of generating text patches, agents can express transformations through code itself. This approach offers several key advantages:
+
+1. **Precision and Reliability**
+
+   - Changes are expressed through well-defined operations
+   - Dependencies and references are handled automatically
+   - Transformations are composable and reusable
+
+2. **Scale and Consistency**
+
+   - Changes can be applied across massive codebases
+   - Transformations remain consistent across files
+   - Complex refactors become tractable
+
+3. **Verifiability and Safety**
+   - Changes are expressed in a reviewable format
+   - Transformations can be tested before application
+   - Operations can be rolled back if needed
+
+## Building Blocks for AI Agents
+
+For AI agents to effectively manipulate code, they need:
+
+1. **A Natural Mental Model**
+
+   - Operations that match how developers think about code changes
+   - High-level abstractions for common patterns
+   - Clear semantics for transformations
+
+2. **Composable Primitives**
+
+   - Basic operations that can be combined
+   - Tools for building higher-level abstractions
+   - Ways to express complex transformations
+
+3. **Rich Static Analysis**
+   - Understanding of dependencies and references
+   - Analysis of control flow and types
+   - Knowledge of cross-file relationships
+
+## The Path Forward
+
+As we move toward more advanced AI coding agents, the ability to act via code becomes increasingly critical. Future AI systems will need to:
+
+1. **Build Their Own Tools**
+
+   - Create custom abstractions for common patterns
+   - Develop specialized transformation utilities
+   - Maintain their own libraries of operations
+
+2. **Reason About Changes**
+
+   - Understand the impact of transformations
+   - Plan complex refactoring operations
+   - Verify the correctness of changes
+
+3. **Learn From Experience**
+   - Improve transformation strategies over time
+   - Develop better abstractions through use
+   - Share knowledge across different contexts
+
+## Conclusion
+
+The path to advanced AI coding agents isn't just about better language models—it's about giving those models the right tools to manipulate code effectively. By enabling AI to "act via code," we create a foundation for more sophisticated, reliable, and scalable code transformation capabilities.
+
+Just as self-driving cars need sophisticated controls to navigate the physical world, AI coding agents need powerful, precise interfaces to manipulate codebases. This programmatic approach creates a shared language that both humans and AI can use to express, verify, and apply code changes reliably at scale.
+
+The future of AI-powered development lies not in generating better patches or diffs, but in enabling AI to work with code the way developers do: through code itself.

docs/blog/codemod-frameworks.mdx

@@ -0,0 +1,223 @@
+---
+title: "A Deep Dive into Codemod Frameworks"
+description: "Comparing popular tools for programmatic code transformation"
+icon: "code-compare"
+iconType: "solid"
+---
+
+Code transformation tools have evolved significantly over the years, each offering unique approaches to programmatic code manipulation. Let's explore the strengths and limitations of major frameworks in this space.
+
+## Python's AST Module
+
+Python's built-in Abstract Syntax Tree (AST) module provides the foundation for Python code manipulation.
+
+### Strengths
+
+- Native Python implementation
+- No external dependencies
+- Full access to Python's syntax tree
+- Great for Python-specific transformations
+
+### Limitations
+
+- Python-only
+- Low-level API requiring deep AST knowledge
+- Manual handling of formatting and comments
+- No cross-file awareness
+
+```python
+import ast
+
+class NameTransformer(ast.NodeTransformer):
+    def visit_Name(self, node):
+        if node.id == 'old_name':
+            return ast.Name(id='new_name', ctx=node.ctx)
+        return node
+```
+
+## LibCST
+
+Meta's Concrete Syntax Tree library offers a more modern approach to Python code modification.
+
+### Strengths
+
+- Preserves formatting and comments
+- Type annotations support
+- Visitor pattern API
+- Excellent documentation
+- Supports codemods at scale
+
+### Limitations
+
+- Python-only
+- Steeper learning curve
+- Slower than raw AST manipulation
+- Memory-intensive for large codebases
+
+```python
+import libcst as cst
+
+class NameTransformer(cst.CSTTransformer):
+    def leave_Name(self, original_node, updated_node):
+        if original_node.value == "old_name":
+            return updated_node.with_changes(value="new_name")
+        return updated_node
+```
+
+## jscodeshift
+
+The pioneer of JavaScript codemods, jscodeshift remains a staple in the JS ecosystem.
+
+### Strengths
+
+- Robust JavaScript/TypeScript support
+- Rich ecosystem of transforms
+- Familiar jQuery-like API
+- Battle-tested at scale
+
+### Limitations
+
+- JavaScript/TypeScript only
+- Limited type information
+- Can be verbose for simple transforms
+- Documentation could be better
+
+```javascript
+export default function transformer(file, api) {
+  const j = api.jscodeshift;
+  return j(file.source)
+    .find(j.Identifier)
+    .filter((path) => path.node.name === "old_name")
+    .replaceWith((path) => j.identifier("new_name"))
+    .toSource();
+}
+```
+
+## ts-morph
+
+A TypeScript-first transformation tool with rich type system integration.
+
+### Strengths
+
+- First-class TypeScript support
+- Excellent type information access
+- High-level, intuitive API
+- Great documentation
+- Project-wide analysis capabilities
+
+### Limitations
+
+- TypeScript/JavaScript only
+- Higher memory usage
+- Can be slower for large projects
+- More complex setup than alternatives
+
+```typescript
+import { Project } from "ts-morph";
+
+const project = new Project();
+project.addSourceFileAtPath("src/**/*.ts");
+project.getSourceFiles().forEach((sourceFile) => {
+  sourceFile
+    .getDescendantsOfKind(SyntaxKind.Identifier)
+    .filter((node) => node.getText() === "old_name")
+    .forEach((node) => node.replaceWithText("new_name"));
+});
+```
+
+## ast-grep
+
+A modern, language-agnostic code searching and rewriting tool.
+
+### Strengths
+
+- Multi-language support
+- Fast pattern matching
+- Simple YAML-based rules
+- Great for quick transformations
+- Excellent performance
+
+### Limitations
+
+- Limited complex transformation support
+- Newer, less battle-tested
+- Smaller ecosystem
+- Less granular control
+
+```yaml
+rules:
+  - pattern: old_name
+    replace: new_name
+```
+
+## tree-sitter
+
+The foundation many modern tools build upon, offering lightning-fast parsing and analysis.
+
+### Strengths
+
+- Incredible performance
+- Multi-language support
+- Incremental parsing
+- Language-agnostic design
+- Growing ecosystem
+
+### Limitations
+
+- Lower-level API
+- Requires language-specific grammars
+- Manual handling of transformations
+- Steeper learning curve
+
+```javascript
+const Parser = require("tree-sitter");
+const JavaScript = require("tree-sitter-javascript");
+
+const parser = new Parser();
+parser.setLanguage(JavaScript);
+const tree = parser.parse('console.log("Hello")');
+```
+
+## Choosing the Right Tool
+
+The choice of codemod framework depends heavily on your specific needs:
+
+- **Single Language Focus**: If you're working exclusively with one language, use its specialized tools:
+
+  - Python → LibCST
+  - TypeScript → ts-morph
+  - JavaScript → jscodeshift
+
+- **Multi-Language Projects**: Consider:
+
+  - ast-grep for simple transformations
+  - tree-sitter for building custom tools
+  - A combination of specialized tools
+
+- **Scale Considerations**:
+  - Small projects → Any tool works
+  - Medium scale → Language-specific tools
+  - Large scale → Need proper tooling support (LibCST, ts-morph)
+
+## The Future of Codemods
+
+As codebases grow and AI becomes more prevalent, we're seeing a shift toward:
+
+1. **More Intelligent Tools**
+
+   - Better type awareness
+   - Improved cross-file analysis
+   - AI-assisted transformations
+
+2. **Universal Approaches**
+
+   - Language-agnostic frameworks
+   - Unified transformation APIs
+   - Better interoperability
+
+3. **Enhanced Developer Experience**
+   - Simpler APIs
+   - Better debugging tools
+   - Richer ecosystems
+
+The ideal codemod framework of the future will likely combine the best aspects of current tools: the type awareness of ts-morph, the simplicity of ast-grep, the performance of tree-sitter, and the reliability of LibCST.

docs/blog/posts.mdx

@@ -0,0 +1,13 @@
+---
+title: "All Posts"
+icon: "clock"
+iconType: "solid"
+---
+
+<Update label="2024-01-24" description="A Deep Dive into Codemod Frameworks">
+  Comparing popular tools for programmatic code transformation
+</Update>
+
+<Update label="2024-01-24" description="Acting via Code">
+  The path to advanced code manipulation agents
+</Update>

docs/mint.json

@@ -46,6 +46,10 @@
 		{
 			"name": "Changelog",
 			"url": "/changelog"
+		},
+		{
+			"name": "Blog",
+			"url": "/blog"
 		}
 	],
 	"navigation": [
@@ -127,6 +131,10 @@
 			"group": "Changelog",
 			"pages": ["changelog/changelog"]
 		},
+		{
+			"group": "Blog",
+			"pages": ["blog/posts", "blog/act-via-code"]
+		},
 		{
 			"group": "API Reference",
 			"pages": [