
Filesystem
- 706 installs
- 36 repo stars
- Updated July 14, 2026
- oimiragieo/agent-studio
filesystem is a Claude Code skill that lets agents safely list, read, write, move, and search project files with consistent path rules so refactors, scaffolds, and bulk edits stay accurate across monorepos.
About
filesystem is a skill from oimiragieo/agent-studio that standardizes how coding agents interact with project files during scaffolds, refactors, and bulk edits. The skill defines path rules and safe operation patterns for listing directories, reading source files, writing new modules, moving assets, and searching across monorepo trees without destructive surprises. Developers reach for filesystem when agent workflows must touch many files consistently—renaming packages, generating boilerplate, or applying codemods—while respecting workspace boundaries. filesystem targets agent builders and engineers wiring autonomous coding pipelines that need predictable file IO semantics. The skill spans multiple development phases because file manipulation remains essential from initial scaffold through iterative refactors in large repositories.
- Navigate monorepos with guardrails
- Batch read or patch multiple paths
- Respect ignore rules and sandbox boundaries
- Create scaffolds and directory structures
- Audit changes before apply
Filesystem by the numbers
- 706 all-time installs (skills.sh)
- +7 installs in the week ending Aug 4, 2026 (Skillselion tracking)
- Ranked #108 of 550 CLI & Terminal skills by installs in the Skillselion catalog
- Data as of Aug 4, 2026 (Skillselion catalog sync)
npx skills add https://github.com/oimiragieo/agent-studio --skill filesystemAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 706 |
|---|---|
| repo stars | ★ 36 |
| Last updated | July 14, 2026 |
| Repository | oimiragieo/agent-studio ↗ |
How do agents safely read and write monorepo files?
Let agents safely list, read, write, move, and search project files with consistent path rules so refactors, scaffolds, and bulk edits stay accurate across monorepos.
Who is it for?
Agent builders wiring automated refactors, scaffolds, or bulk file edits that must stay accurate across monorepos.
Skip if: Developers needing only manual single-file edits without agent automation should skip filesystem.
When should I use this skill?
The user needs agents to list, read, write, move, or search project files with consistent path rules during refactors or scaffolds.
What you get
Path-safe file listings, reads, writes, moves, and search results across project directories during agent workflows.
Files
Filesystem Skill
<identity> Filesystem Skill - Guidance for file system operations using Claude Code's built-in tools. Read, write, search, and manage files efficiently. </identity>
<capabilities>
- Reading single or multiple files
- Creating or modifying files
- Searching for files by pattern
- Searching file contents
- Directory navigation
</capabilities>
<instructions> <execution_process>
Claude Code Built-in Tools
Reading Files
Read Tool: Read file contents
Read file_path="/path/to/file.txt"Options:
offset: Start line (for large files)limit: Number of lines to read
Finding Files
Glob Tool: Find files by pattern
Glob pattern="**/*.ts"Common patterns:
**/*.ts- All TypeScript filessrc/**/*.tsx- React components in src**/test*.js- Test files anywhere
Searching Content
Primary Search: Use pnpm search:code "query" or Skill({ skill: 'ripgrep' }) for content searching. The built-in Grep tool is fallback-only.
Grep Tool: Search file contents (fallback only — prefer pnpm search:code or ripgrep skill first)
Grep pattern="function myFunc" path="/src"Options:
output_mode: "content", "files_with_matches", or "count"-A,-B,-C: Context lines
Writing Files
Write Tool: Create or overwrite files
Write file_path="/path/to/file.txt" content="..."Edit Tool: Modify existing files
Edit file_path="/path/to/file.txt" old_string="..." new_string="..."Directory Operations
Bash Tool: For directory operations
# List directory
ls -la /path/to/dir
# Create directory
mkdir -p /path/to/new/dir
# Move/rename
mv /old/path /new/path</execution_process>
<best_practices>
Common Workflows
Reading Multiple Files
# Read files in parallel (multiple Read calls in one message)
Read file_path="/src/app.ts"
Read file_path="/src/config.ts"
Read file_path="/src/utils.ts"Search and Read
# 1. Find files
Glob pattern="**/*.config.ts"
# 2. Read matching files
Read file_path="/path/from/glob/result"Find and Replace
# 1. Search for pattern
Grep pattern="oldFunction" path="/src"
# 2. Edit each file
Edit file_path="/src/file.ts" old_string="oldFunction" new_string="newFunction"Best Practices
1. Read Before Edit: Always read a file before editing it 2. Use Glob Over Bash: Prefer Glob to find for file discovery 3. Search Tool Hierarchy: Use pnpm search:code or Skill({ skill: 'ripgrep' }) first; use the Grep tool as fallback over raw bash grep only 4. Parallel Reads: Read multiple files in one message for speed 5. Verify Changes: Read file after editing to verify
</best_practices> </instructions>
<examples> <usage_example> Find and read all TypeScript files:
Glob pattern="src/**/*.ts"
# Then read the results
Read file_path="/src/app.ts"</usage_example>
<usage_example> Search for a function and edit it:
Grep pattern="export function oldName" path="/src"
# Found in /src/utils.ts:23
Edit file_path="/src/utils.ts" old_string="export function oldName" new_string="export function newName"</usage_example> </examples>
Rules
- Always read files before editing
- Use built-in tools (Read, Glob, Grep) instead of bash equivalents
- Verify changes after editing
Memory Protocol (MANDATORY)
Before starting:
cat .claude/context/memory/learnings.mdAfter completing:
- New pattern ->
.claude/context/memory/learnings.md - Issue found ->
.claude/context/memory/issues.md - Decision made ->
.claude/context/memory/decisions.md
ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.
Invoke the filesystem skill and follow it exactly as presented to you
'use strict';
/**
* Post-execute hook for filesystem
* Auto-generated by enterprise-bundle-scaffolder
*
* Records metrics after skill execution.
*/
function postExecute(_context) {
// Record execution metrics
return { ok: true, skill: 'filesystem' };
}
module.exports = { postExecute };
'use strict';
/**
* Pre-execute hook for filesystem
* Auto-generated by enterprise-bundle-scaffolder
*
* Validates inputs before skill execution.
*/
function preExecute(context) {
// Validate skill invocation context
if (!context || typeof context !== 'object') {
return { allow: true, message: 'filesystem: no context to validate' };
}
return { allow: true };
}
module.exports = { preExecute };
filesystem Research Requirements
Generated: 2026-02-28
Skill Description
File system operations guidance - read, write, search, and manage files using Claude Code's built-in tools.
Research Areas
- Current best practices for filesystem
- Industry standards and tooling
- Integration patterns
Source References
- To be populated by skill-updater research phase
filesystem Rules
Purpose
File system operations guidance - read, write, search, and manage files using Claude Code's built-in tools.
Best Practices
- Use Read for file contents
- Use Glob for file pattern matching
- Use pnpm search:code or ripgrep skill for content searching; Grep tool is fallback-only
- Use Edit for modifications
Integration Points
See SKILL.md for complete documentation.
{
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "filesystemInput",
"description": "Input schema for File system operations guidance - read, write, search, and manage files using Claude Code's built-in tools.",
"type": "object",
"additionalProperties": true,
"properties": {
"target": {
"type": "string",
"description": "Target file or path for the skill to operate on"
},
"options": {
"type": "object",
"description": "Additional options for skill execution",
"additionalProperties": true
}
}
}
{
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "filesystemOutput",
"type": "object",
"additionalProperties": true,
"properties": {
"ok": {
"type": "boolean"
},
"summary": {
"type": "string"
}
}
}
#!/usr/bin/env node
'use strict';
/**
* filesystem - Enterprise Skill Script
* Auto-generated by enterprise-bundle-scaffolder
*/
const fs = require('fs');
const path = require('path');
// Parse arguments
const args = process.argv.slice(2);
const options = {};
for (let i = 0; i < args.length; i++) {
if (args[i].startsWith('--')) {
const key = args[i].slice(2);
const value = args[i + 1] && !args[i + 1].startsWith('--') ? args[++i] : true;
options[key] = value;
}
}
if (options.help) {
console.log(`
filesystem - Enterprise Skill
Usage:
node main.cjs --check <file> Check a file against guidelines
node main.cjs --list List all guidelines
node main.cjs --help Show this help
Description:
File system operations guidance - read, write, search, and manage files using Claude Code's built-in tools.
`);
process.exit(0);
}
if (options.list) {
console.log('Guidelines for filesystem:');
console.log('See SKILL.md for full guidelines');
process.exit(0);
}
console.log('filesystem skill loaded. Use with Claude for code review.');
filesystem Implementation Template
Goal
- Define target outcome and acceptance criteria.
TDD
1. Red 2. Green 3. Refactor
Verification
- lint
- format
- targeted tests
Related skills
FAQ
What file operations does filesystem support for agents?
filesystem lets agents list, read, write, move, and search project files under consistent path rules. Agent builders use it so scaffolds, refactors, and bulk edits stay accurate across monorepo workspaces.
Why use filesystem instead of ad hoc file commands?
filesystem standardizes path boundaries and operation patterns for agent-studio workflows. Teams adopt it when autonomous coding steps must avoid destructive edits or inconsistent directory handling during large refactors.