llmview 0.1.0 → 0.2.0

package/README.md

@@ -20,9 +20,9 @@ Create any number of view files in your project. These can be saved anywhere. Fo
     new_feature.llmview
 ```
 
-And use them selectively:
+And use one:
 
-```
+```bash
 llmview .views/backend.llmview
 ```
 
@@ -96,24 +96,30 @@ my_project/
 
 The `-n` argument includes line numbers in each file, similar to `cat -n`. This uses more tokens, but can also be useful context.
 
-## Integrating with your tools
+### Only list selected files
+
+The `-l` argument lets you use selected files for something else besides rendering the context to stdout. For example, to create a zip of selected files.
+
+```bash
+llmview .views/backend.llmview -l | zip context.zip -@
+```
 
-For agentic tools, you can ask an agent to use the `llmview` command itself with views you defined. This might save it some time getting up to speed on your project, especially across sessions.
+### Using `llmview` as a filter
 
-For interactive use such as code reviews, you can pipe the results to an API or just copy the contents to your clipboard and paste into a LLM web app, like:
+Instead of reading from a view file, you can use it as a filter. For example, to render all the unstaged changes in your repo:
 
 ```bash
-llmview .views/backend.llmview | pbcopy
+git diff --name-only | llmview -
 ```
 
 ## Renderers
 
-This tool comes with a set of opinionated file renderers. They are informed by the file extension. Exceptions are made for:
+This tool comes with a set of opinionated file renderers based on the file extension. Currently they are:
 
 - CSV (truncated by default, preserving the header and the first 10 lines)
 - Excel, media files, and other non-text formats (omitted)
 
-There is also a max size of 250KB per file. If a file is larger than that, it is not rendered.
+There is also a max size of 250KB per file. If a code file is larger than that, it is not rendered. (If a CSV file is larger, it's still rendered and just truncated as usual.)
 
 ## Dry run to get statistics
 

package/dist/build.js

@@ -34,24 +34,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDirectory = void 0;
-const os = __importStar(require("os"));
-const fs = __importStar(require("fs"));
+const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
-const git_1 = require("./git");
+const ignore_1 = require("./ignore");
 const constants_1 = require("./constants");
-const expandUser = (inputPath) => {
-    return inputPath.replace(/^~/, os.homedir());
-};
-const buildDirectory = (projectPath) => {
-    projectPath = expandUser(projectPath);
+const buildDirectory = async (projectPath) => {
     const ignores = [
-        { ig: (0, git_1.createIgnore)(constants_1.BASE_IGNORE_CONTENT), scope: '' },
+        { ig: (0, ignore_1.createIgnore)(constants_1.BASE_IGNORE_CONTENT), scope: '' },
     ];
-    const rootGitignore = (0, git_1.createIgnoreFromFile)(path.join(projectPath, '.gitignore'));
+    const rootGitignore = await (0, ignore_1.createIgnoreFromFile)(path.join(projectPath, '.gitignore'));
     if (rootGitignore) {
         ignores.push({ ig: rootGitignore, scope: '' });
     }
-    const stat = fs.statSync(projectPath);
+    const stat = await fs.stat(projectPath);
     const rootNode = {
         ino: stat.ino,
         name: path.basename(projectPath),
@@ -62,17 +57,17 @@ const buildDirectory = (projectPath) => {
         rootPath: projectPath,
         children: [],
     };
-    rootNode.children = buildChildrenNodes(projectPath, rootNode, ignores);
+    rootNode.children = await buildChildrenNodes(projectPath, rootNode, ignores);
     return rootNode;
 };
 exports.buildDirectory = buildDirectory;
-const buildChildrenNodes = (rootPath, parentNode, ignores) => {
+const buildChildrenNodes = async (rootPath, parentNode, ignores) => {
     const currentPath = path.join(rootPath, parentNode.relativePath);
-    const entries = fs.readdirSync(currentPath);
+    const entries = await fs.readdir(currentPath);
     const nodes = [];
     for (const entry of entries) {
         const entryFullPath = path.join(currentPath, entry);
-        const lstat = fs.lstatSync(entryFullPath);
+        const lstat = await fs.lstat(entryFullPath);
         if (lstat.isSymbolicLink()) {
             continue;
         }
@@ -80,7 +75,7 @@ const buildChildrenNodes = (rootPath, parentNode, ignores) => {
         const nodeRelativePath = parentNode.relativePath
             ? `${parentNode.relativePath}/${entry}`
             : entry;
-        if ((0, git_1.isPathIgnored)(nodeRelativePath, isDirectory, ignores)) {
+        if ((0, ignore_1.isPathIgnored)(nodeRelativePath, isDirectory, ignores)) {
             continue;
         }
         const nodeBase = {
@@ -96,17 +91,18 @@ const buildChildrenNodes = (rootPath, parentNode, ignores) => {
                 type: 'directory',
                 children: [],
             };
-            const nestedIg = (0, git_1.createIgnoreFromFile)(path.join(entryFullPath, '.gitignore'));
+            const nestedIg = await (0, ignore_1.createIgnoreFromFile)(path.join(entryFullPath, '.gitignore'));
             const childIgnores = nestedIg
                 ? [...ignores, { ig: nestedIg, scope: nodeRelativePath }]
                 : ignores;
-            dirNode.children = buildChildrenNodes(rootPath, dirNode, childIgnores);
+            dirNode.children = await buildChildrenNodes(rootPath, dirNode, childIgnores);
             nodes.push(dirNode);
         }
         else {
             const fileNode = {
                 ...nodeBase,
                 type: 'file',
+                size: lstat.size,
             };
             nodes.push(fileNode);
         }

package/dist/cli.js

@@ -34,13 +34,43 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __importStar(require("fs"));
+const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const build_1 = require("./build");
 const render_1 = require("./render");
 const select_1 = require("./select");
-const parseLlmviewFile = (filePath) => {
-    const content = fs.readFileSync(filePath, 'utf-8');
+const constants_1 = require("./constants");
+const readStdin = () => {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on('data', (chunk) => chunks.push(chunk));
+        process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        process.stdin.on('error', reject);
+    });
+};
+const readPatterns = async (pathArg) => {
+    let content;
+    if (!pathArg || pathArg === '-') {
+        if (process.stdin.isTTY) {
+            console.error('Error: No input file specified and stdin is a terminal');
+            console.error('Usage: llmview <view-file> or pipe patterns via stdin');
+            process.exit(1);
+        }
+        content = await readStdin();
+    }
+    else {
+        const resolvedPath = path.resolve(pathArg);
+        try {
+            content = await fs.readFile(resolvedPath, 'utf-8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                console.error(`File not found: ${resolvedPath}`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    }
     return content
         .split('\n')
         .map((line) => line.trim())
@@ -51,15 +81,16 @@ const HELP_TEXT = `llmview - Generate LLM context from codebases using gitignore
 Usage: llmview [options] <view-file>
 
 Arguments:
-  <view-file>    Path to a .llmview file containing glob patterns
+  <view-file>    Path to a .llmview file, or - to read patterns from stdin
 
 Options:
+  -l, --list     List selected files only (no content)
   -n, --number   Include line numbers in output
   -t, --tree     Include directory tree of selected files
   -v, --verbose  Print file statistics to stderr
   -h, --help     Show this help message
 `;
-const main = () => {
+const main = async () => {
     const args = process.argv.slice(2);
     if (args.includes('-h') || args.includes('--help')) {
         console.log(HELP_TEXT);
@@ -68,37 +99,36 @@ const main = () => {
     const verbose = args.includes('-v') || args.includes('--verbose');
     const includeTree = args.includes('-t') || args.includes('--tree');
     const lineNumbers = args.includes('-n') || args.includes('--number');
-    const llmviewPath = args.find((arg) => !arg.startsWith('-'));
-    if (!llmviewPath) {
-        console.log(HELP_TEXT);
-        process.exit(1);
-    }
-    const resolvedPath = path.resolve(llmviewPath);
-    if (!fs.existsSync(resolvedPath)) {
-        console.error(`File not found: ${resolvedPath}`);
-        process.exit(1);
-    }
-    const patterns = parseLlmviewFile(resolvedPath);
+    const listOnly = args.includes('-l') || args.includes('--list');
+    const positionalArgs = args.filter((arg) => !arg.startsWith('-'));
+    const patterns = await readPatterns(positionalArgs[0]);
     if (patterns.length === 0) {
-        console.error('No patterns found in llmview file');
+        console.error('No patterns found in input');
         process.exit(1);
     }
-    const rootNode = (0, build_1.buildDirectory)(process.cwd());
+    const rootNode = await (0, build_1.buildDirectory)(process.cwd());
     const { selectedFiles, visiblePaths } = (0, select_1.selectFiles)(rootNode, patterns, {
         verbose,
     });
+    if (listOnly) {
+        selectedFiles.forEach((file) => console.log(file.relativePath));
+        process.exit(0);
+    }
     let output = '';
     if (includeTree) {
-        output += (0, render_1.renderHierarchy)(rootNode, { verbose }, visiblePaths);
+        output += (0, render_1.renderDirectory)(rootNode, { verbose }, visiblePaths);
     }
-    output += (0, render_1.renderFiles)(rootNode.rootPath, selectedFiles, {
+    output += await (0, render_1.renderFiles)(rootNode.rootPath, selectedFiles, {
         verbose,
         lineNumbers,
     });
-    const estimatedTokens = Math.ceil(output.length / 4);
+    const estimatedTokens = Math.ceil(output.length / constants_1.CHARS_PER_TOKEN_ESTIMATE);
     if (verbose) {
         console.warn(`Estimated tokens: ${estimatedTokens}`);
     }
     console.log(output);
 };
-main();
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/constants.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_FILE_SIZE_KB = exports.BASE_IGNORE_CONTENT = void 0;
+exports.CHARS_PER_TOKEN_ESTIMATE = exports.CSV_PREVIEW_LINES = exports.MAX_FILE_SIZE_KB = exports.BASE_IGNORE_CONTENT = void 0;
 exports.BASE_IGNORE_CONTENT = `.git
 .DS_Store
 __pycache__/
 node_modules/`;
 exports.MAX_FILE_SIZE_KB = 250;
+exports.CSV_PREVIEW_LINES = 10;
+exports.CHARS_PER_TOKEN_ESTIMATE = 4;

package/dist/{git.js → ignore.js}

@@ -37,13 +37,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPathIgnored = exports.createIgnore = exports.createIgnoreFromFile = void 0;
-const fs = __importStar(require("fs"));
+const fs = __importStar(require("fs/promises"));
 const ignore_1 = __importDefault(require("ignore"));
-const createIgnoreFromFile = (gitignorePath) => {
-    if (!fs.existsSync(gitignorePath)) {
+const createIgnoreFromFile = async (gitignorePath) => {
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf8');
+        return (0, ignore_1.default)().add(content);
+    }
+    catch {
         return undefined;
     }
-    return (0, ignore_1.default)().add(fs.readFileSync(gitignorePath, 'utf8'));
 };
 exports.createIgnoreFromFile = createIgnoreFromFile;
 const createIgnore = (content) => {

package/dist/{renderers.js → render-rules.js}

@@ -35,47 +35,28 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RENDER_RULES = exports.defaultRenderer = void 0;
 const fs = __importStar(require("fs"));
+const fsPromises = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
 const constants_1 = require("./constants");
-const readFirstNLines = (filePath, n) => {
-    const fd = fs.openSync(filePath, 'r');
-    const bufferSize = 64 * 1024;
-    const buffer = Buffer.alloc(bufferSize);
+const readFirstNLines = async (filePath, n) => {
     const lines = [];
-    let leftover = '';
-    let hasMore = false;
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
     try {
-        while (lines.length < n) {
-            const bytesRead = fs.readSync(fd, buffer, 0, bufferSize, null);
-            if (bytesRead === 0)
-                break; // EOF
-            const chunk = leftover + buffer.toString('utf-8', 0, bytesRead);
-            const chunkLines = chunk.split('\n');
-            leftover = chunkLines.pop() || '';
-            for (const line of chunkLines) {
-                if (lines.length < n) {
-                    lines.push(line);
-                }
-                else {
-                    hasMore = true;
-                    break;
-                }
-            }
-            if (hasMore)
-                break;
-        }
-        if (!hasMore && lines.length >= n) {
-            if (leftover !== '') {
-                hasMore = true;
+        for await (const line of rl) {
+            if (lines.length < n) {
+                lines.push(line);
             }
             else {
-                hasMore = fs.readSync(fd, buffer, 0, 1, null) > 0;
+                return { lines, hasMore: true };
             }
         }
-        return { lines, hasMore };
+        return { lines, hasMore: false };
     }
     finally {
-        fs.closeSync(fd);
+        rl.close();
+        stream.destroy();
     }
 };
 const numberLines = (lines) => {
@@ -86,13 +67,12 @@ const numberLines = (lines) => {
     })
         .join('\n');
 };
-const defaultRenderer = (rootPath, file, options) => {
+const defaultRenderer = async (rootPath, file, options) => {
     const fullPath = path.join(rootPath, file.relativePath);
-    const stats = fs.statSync(fullPath);
-    if (stats.size > constants_1.MAX_FILE_SIZE_KB * 1024) {
-        return `(File contents excluded: size ${(stats.size / 1024).toFixed(2)}KB exceeds ${constants_1.MAX_FILE_SIZE_KB}KB limit)`;
+    if (file.size > constants_1.MAX_FILE_SIZE_KB * 1024) {
+        return `(File contents excluded: size ${(file.size / 1024).toFixed(2)}KB exceeds ${constants_1.MAX_FILE_SIZE_KB}KB limit)`;
     }
-    const content = fs.readFileSync(fullPath, 'utf-8');
+    const content = await fsPromises.readFile(fullPath, 'utf-8');
     if (options.lineNumbers) {
         const lines = content.split('\n');
         return numberLines(lines);
@@ -104,9 +84,9 @@ exports.RENDER_RULES = [
     // csv
     {
         matcher: (name) => ['.csv'].some((ext) => name.toLowerCase().endsWith(ext)),
-        renderer: (rootPath, file, options) => {
+        renderer: async (rootPath, file, options) => {
             const fullPath = path.join(rootPath, file.relativePath);
-            const { lines, hasMore } = readFirstNLines(fullPath, 10);
+            const { lines, hasMore } = await readFirstNLines(fullPath, constants_1.CSV_PREVIEW_LINES);
             const preview = options.lineNumbers
                 ? numberLines(lines)
                 : lines.join('\n');
@@ -116,16 +96,16 @@ exports.RENDER_RULES = [
     // excel
     {
         matcher: (name) => ['.xls', '.xlsx'].some((ext) => name.toLowerCase().endsWith(ext)),
-        renderer: (rootPath, file, options) => '(Contents excluded)',
+        renderer: async () => '(Contents excluded)',
     },
     // media
     {
         matcher: (name) => ['.ico', '.png', '.jpg', '.jpeg', '.gif', '.webp', '.mp4'].some((ext) => name.toLowerCase().endsWith(ext)),
-        renderer: (rootPath, file, options) => '(Contents excluded)',
+        renderer: async () => '(Contents excluded)',
     },
     // misc
     {
         matcher: (name) => ['.pdf', '.zip'].some((ext) => name.toLowerCase().endsWith(ext)),
-        renderer: (rootPath, file, options) => '(Contents excluded)',
+        renderer: async () => '(Contents excluded)',
     },
 ];

package/dist/render.js

@@ -1,48 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderFiles = exports.renderHierarchy = void 0;
-const renderers_1 = require("./renderers");
-const renderHierarchy = (node, options, visiblePaths, currentDepth = 0) => {
-    if (visiblePaths &&
-        node.relativePath &&
-        !visiblePaths.has(node.relativePath)) {
-        return null;
-    }
+exports.renderFiles = exports.renderDirectory = void 0;
+const render_rules_1 = require("./render-rules");
+const renderDirectory = (rootNode, options, visiblePaths) => {
+    return renderDirectoryNode(rootNode, options, visiblePaths, 0);
+};
+exports.renderDirectory = renderDirectory;
+const renderDirectoryNode = (node, options, visiblePaths, currentDepth) => {
     const { indentChar = '    ' } = options;
     const indent = indentChar.repeat(currentDepth);
     if (node.type === 'file') {
         return `${indent}${node.name}`;
     }
-    let result = `${indent}${node.name}/`;
-    if (node.children.length === 0) {
-        return result;
-    }
     const childrenOutput = node.children
-        .map((child) => (0, exports.renderHierarchy)(child, options, visiblePaths, currentDepth + 1))
-        .filter((output) => output !== null)
+        .filter((child) => !visiblePaths ||
+        !child.relativePath ||
+        visiblePaths.has(child.relativePath))
+        .map((child) => renderDirectoryNode(child, options, visiblePaths, currentDepth + 1))
         .join('\n');
+    const result = `${indent}${node.name}/`;
     if (currentDepth === 0) {
-        return `\`\`\`
-<directory>
-${result}
-${childrenOutput}
-</directory>
-\`\`\`\n\n`;
-    }
-    else {
-        return `${result}\n${childrenOutput}`;
+        return `\`\`\`\n<directory>\n${result}\n${childrenOutput}\n</directory>\n\`\`\`\n\n`;
     }
+    return childrenOutput ? `${result}\n${childrenOutput}` : result;
 };
-exports.renderHierarchy = renderHierarchy;
-const renderFiles = (rootPath, files, options) => {
-    return files
-        .map((file) => renderFileBlock(rootPath, file, options))
-        .join('\n\n');
+const renderFiles = async (rootPath, files, options) => {
+    const renderedBlocks = await Promise.all(files.map((file) => renderFile(rootPath, file, options)));
+    return renderedBlocks.join('\n\n');
 };
 exports.renderFiles = renderFiles;
-const renderFileBlock = (rootPath, file, options) => {
+const renderFile = async (rootPath, file, options) => {
     const renderer = getRenderer(file);
-    const rendered = renderer(rootPath, file, options);
+    const rendered = await renderer(rootPath, file, options);
     if (options.verbose) {
         console.warn({ path: file.relativePath, length: rendered.length });
     }
@@ -53,10 +42,10 @@ ${rendered}
 \`\`\``;
 };
 const getRenderer = (file) => {
-    for (const { matcher, renderer } of renderers_1.RENDER_RULES) {
+    for (const { matcher, renderer } of render_rules_1.RENDER_RULES) {
         if (matcher(file.name)) {
             return renderer;
         }
     }
-    return renderers_1.defaultRenderer;
+    return render_rules_1.defaultRenderer;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llmview",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "bin": {
     "llmview": "dist/cli.js"
   },
@@ -22,10 +22,7 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.8.2"
   },
-  "files": [
-    "dist",
-    "README.md"
-  ],
+  "files": ["dist", "README.md"],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/noahtren/llmview.git"