llmview 0.1.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2026
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,126 @@
+# llmview
+
+`llmview` is a small command-line tool for producing repeatable views of code for LLMs. You can configure views for different aspects of a large project and reuse them as the code evolves.
+
+## Quick start
+
+Install from npm
+
+```bash
+npm install -g llmview
+```
+
+Create any number of view files in your project. These can be saved anywhere. For example, a full-stack monorepo:
+
+```
+.views/
+    backend.llmview
+    frontend.llmview
+    integration_tests.llmview
+    new_feature.llmview
+```
+
+And use them selectively:
+
+```
+llmview .views/backend.llmview
+```
+
+Run `llmview --help` for all options.
+
+## How it works
+
+A view is a list of glob patterns to select. It's the same format as `.gitignore`, but it says which patterns to select rather than ignore.
+
+```gitignore
+# Code
+backend/**/**
+!backend/migrations/**
+
+# Docs
+docs/style_guide.md
+```
+
+It will find all files that satisfy the glob patterns. It also respects existing `.gitignore` files (even nested ones) if your project is version controlled. If any files are ignored by git, they are also ignored here even if the view file would have selected it.
+
+After selecting, it serializes the contents of each file into a LLM-friendly format and prints to stdout.
+
+````
+```
+<file path="backend/main.py">
+from flask import Flask
+
+app = Flask(__name__)
+
+@app.route("/")
+def hello():
+    return "Hello, World!"
+
+if __name__ == "__main__":
+    app.run(debug=True)
+
+</file>
+```
+
+```
+<file path="docs/style_guide.md">
+# Style guide
+
+Make no mistakes
+
+</file>
+```
+````
+
+### Including the project directory
+
+The `-t` argument includes the file system hierarchy for all selected files at the beginning of the result.
+
+````
+```
+<directory>
+my_project/
+    backend/
+        main.py
+    docs/
+        style_guide.md
+</directory>
+```
+
+```
+<file path="my_project/backend/main.py">
+...
+````
+
+### Including line numbers
+
+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
+
+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.
+
+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:
+
+```bash
+llmview .views/backend.llmview | pbcopy
+```
+
+## Renderers
+
+This tool comes with a set of opinionated file renderers. They are informed by the file extension. Exceptions are made for:
+
+- 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.
+
+## Dry run to get statistics
+
+To see what files will be included and an estimate of tokens used, try a command like this:
+
+```bash
+llmview -v .views/backend.llmview > /dev/null
+```
+
+This works because verbose information gets printed to stderr, and stdout goes to `/dev/null`.

package/dist/build.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDirectory = void 0;
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const git_1 = require("./git");
+const constants_1 = require("./constants");
+const expandUser = (inputPath) => {
+    return inputPath.replace(/^~/, os.homedir());
+};
+const buildDirectory = (projectPath) => {
+    projectPath = expandUser(projectPath);
+    const ignores = [
+        { ig: (0, git_1.createIgnore)(constants_1.BASE_IGNORE_CONTENT), scope: '' },
+    ];
+    const rootGitignore = (0, git_1.createIgnoreFromFile)(path.join(projectPath, '.gitignore'));
+    if (rootGitignore) {
+        ignores.push({ ig: rootGitignore, scope: '' });
+    }
+    const stat = fs.statSync(projectPath);
+    const rootNode = {
+        ino: stat.ino,
+        name: path.basename(projectPath),
+        relativePath: '',
+        createdAt: stat.birthtime,
+        updatedAt: stat.mtime,
+        type: 'directory',
+        rootPath: projectPath,
+        children: [],
+    };
+    rootNode.children = buildChildrenNodes(projectPath, rootNode, ignores);
+    return rootNode;
+};
+exports.buildDirectory = buildDirectory;
+const buildChildrenNodes = (rootPath, parentNode, ignores) => {
+    const currentPath = path.join(rootPath, parentNode.relativePath);
+    const entries = fs.readdirSync(currentPath);
+    const nodes = [];
+    for (const entry of entries) {
+        const entryFullPath = path.join(currentPath, entry);
+        const lstat = fs.lstatSync(entryFullPath);
+        if (lstat.isSymbolicLink()) {
+            continue;
+        }
+        const isDirectory = lstat.isDirectory();
+        const nodeRelativePath = parentNode.relativePath
+            ? `${parentNode.relativePath}/${entry}`
+            : entry;
+        if ((0, git_1.isPathIgnored)(nodeRelativePath, isDirectory, ignores)) {
+            continue;
+        }
+        const nodeBase = {
+            ino: lstat.ino,
+            name: entry,
+            relativePath: nodeRelativePath,
+            createdAt: lstat.birthtime,
+            updatedAt: lstat.mtime,
+        };
+        if (isDirectory) {
+            const dirNode = {
+                ...nodeBase,
+                type: 'directory',
+                children: [],
+            };
+            const nestedIg = (0, git_1.createIgnoreFromFile)(path.join(entryFullPath, '.gitignore'));
+            const childIgnores = nestedIg
+                ? [...ignores, { ig: nestedIg, scope: nodeRelativePath }]
+                : ignores;
+            dirNode.children = buildChildrenNodes(rootPath, dirNode, childIgnores);
+            nodes.push(dirNode);
+        }
+        else {
+            const fileNode = {
+                ...nodeBase,
+                type: 'file',
+            };
+            nodes.push(fileNode);
+        }
+    }
+    return nodes.sort((a, b) => {
+        if (a.type !== b.type) {
+            return a.type === 'directory' ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+    });
+};

package/dist/cli.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+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');
+    return content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '' && !line.startsWith('#'));
+};
+const HELP_TEXT = `llmview - Generate LLM context from codebases using gitignore-style patterns
+
+Usage: llmview [options] <view-file>
+
+Arguments:
+  <view-file>    Path to a .llmview file containing glob patterns
+
+Options:
+  -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 args = process.argv.slice(2);
+    if (args.includes('-h') || args.includes('--help')) {
+        console.log(HELP_TEXT);
+        process.exit(0);
+    }
+    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);
+    if (patterns.length === 0) {
+        console.error('No patterns found in llmview file');
+        process.exit(1);
+    }
+    const rootNode = (0, build_1.buildDirectory)(process.cwd());
+    const { selectedFiles, visiblePaths } = (0, select_1.selectFiles)(rootNode, patterns, {
+        verbose,
+    });
+    let output = '';
+    if (includeTree) {
+        output += (0, render_1.renderHierarchy)(rootNode, { verbose }, visiblePaths);
+    }
+    output += (0, render_1.renderFiles)(rootNode.rootPath, selectedFiles, {
+        verbose,
+        lineNumbers,
+    });
+    const estimatedTokens = Math.ceil(output.length / 4);
+    if (verbose) {
+        console.warn(`Estimated tokens: ${estimatedTokens}`);
+    }
+    console.log(output);
+};
+main();

package/dist/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;

package/dist/git.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathIgnored = exports.createIgnore = exports.createIgnoreFromFile = void 0;
+const fs = __importStar(require("fs"));
+const ignore_1 = __importDefault(require("ignore"));
+const createIgnoreFromFile = (gitignorePath) => {
+    if (!fs.existsSync(gitignorePath)) {
+        return undefined;
+    }
+    return (0, ignore_1.default)().add(fs.readFileSync(gitignorePath, 'utf8'));
+};
+exports.createIgnoreFromFile = createIgnoreFromFile;
+const createIgnore = (content) => {
+    return (0, ignore_1.default)().add(content);
+};
+exports.createIgnore = createIgnore;
+const isPathIgnored = (relativePath, isDirectory, ignores) => {
+    const pathToCheck = isDirectory ? `${relativePath}/` : relativePath;
+    let ignored = false;
+    for (const { ig, scope } of ignores) {
+        const localPath = scope === ''
+            ? pathToCheck
+            : pathToCheck.startsWith(scope + '/')
+                ? pathToCheck.slice(scope.length + 1)
+                : null;
+        if (localPath === null)
+            continue;
+        const result = ig.test(localPath);
+        if (result.ignored) {
+            ignored = true;
+        }
+        else if (result.unignored) {
+            ignored = false;
+        }
+    }
+    return ignored;
+};
+exports.isPathIgnored = isPathIgnored;

package/dist/render.js

@@ -0,0 +1,62 @@
+"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;
+    }
+    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)
+        .join('\n');
+    if (currentDepth === 0) {
+        return `\`\`\`
+<directory>
+${result}
+${childrenOutput}
+</directory>
+\`\`\`\n\n`;
+    }
+    else {
+        return `${result}\n${childrenOutput}`;
+    }
+};
+exports.renderHierarchy = renderHierarchy;
+const renderFiles = (rootPath, files, options) => {
+    return files
+        .map((file) => renderFileBlock(rootPath, file, options))
+        .join('\n\n');
+};
+exports.renderFiles = renderFiles;
+const renderFileBlock = (rootPath, file, options) => {
+    const renderer = getRenderer(file);
+    const rendered = renderer(rootPath, file, options);
+    if (options.verbose) {
+        console.warn({ path: file.relativePath, length: rendered.length });
+    }
+    return `\`\`\`
+<file path="${file.relativePath}">
+${rendered}
+</file>
+\`\`\``;
+};
+const getRenderer = (file) => {
+    for (const { matcher, renderer } of renderers_1.RENDER_RULES) {
+        if (matcher(file.name)) {
+            return renderer;
+        }
+    }
+    return renderers_1.defaultRenderer;
+};

package/dist/renderers.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RENDER_RULES = exports.defaultRenderer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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 lines = [];
+    let leftover = '';
+    let hasMore = false;
+    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;
+            }
+            else {
+                hasMore = fs.readSync(fd, buffer, 0, 1, null) > 0;
+            }
+        }
+        return { lines, hasMore };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+};
+const numberLines = (lines) => {
+    return lines
+        .map((line, index) => {
+        const lineNumber = (index + 1).toString().padStart(6, ' ');
+        return `${lineNumber}\t${line}`;
+    })
+        .join('\n');
+};
+const defaultRenderer = (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)`;
+    }
+    const content = fs.readFileSync(fullPath, 'utf-8');
+    if (options.lineNumbers) {
+        const lines = content.split('\n');
+        return numberLines(lines);
+    }
+    return content;
+};
+exports.defaultRenderer = defaultRenderer;
+exports.RENDER_RULES = [
+    // csv
+    {
+        matcher: (name) => ['.csv'].some((ext) => name.toLowerCase().endsWith(ext)),
+        renderer: (rootPath, file, options) => {
+            const fullPath = path.join(rootPath, file.relativePath);
+            const { lines, hasMore } = readFirstNLines(fullPath, 10);
+            const preview = options.lineNumbers
+                ? numberLines(lines)
+                : lines.join('\n');
+            return hasMore ? `${preview}\n... (more rows)` : preview;
+        },
+    },
+    // excel
+    {
+        matcher: (name) => ['.xls', '.xlsx'].some((ext) => name.toLowerCase().endsWith(ext)),
+        renderer: (rootPath, file, options) => '(Contents excluded)',
+    },
+    // media
+    {
+        matcher: (name) => ['.ico', '.png', '.jpg', '.jpeg', '.gif', '.webp', '.mp4'].some((ext) => name.toLowerCase().endsWith(ext)),
+        renderer: (rootPath, file, options) => '(Contents excluded)',
+    },
+    // misc
+    {
+        matcher: (name) => ['.pdf', '.zip'].some((ext) => name.toLowerCase().endsWith(ext)),
+        renderer: (rootPath, file, options) => '(Contents excluded)',
+    },
+];

package/dist/select.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVisiblePaths = exports.selectFiles = void 0;
+const minimatch_1 = require("minimatch");
+const selectFiles = (node, globPatterns, options) => {
+    const allFiles = listAllFiles(node);
+    const selectedFiles = allFiles.filter((file) => {
+        let included = false;
+        for (const pattern of globPatterns) {
+            if (pattern.startsWith('!')) {
+                if ((0, minimatch_1.minimatch)(file.relativePath, pattern.slice(1), { dot: true })) {
+                    included = false;
+                }
+            }
+            else {
+                if ((0, minimatch_1.minimatch)(file.relativePath, pattern, { dot: true })) {
+                    included = true;
+                }
+            }
+        }
+        return included;
+    });
+    const visiblePaths = (0, exports.getVisiblePaths)(selectedFiles);
+    if (options.verbose) {
+        if (selectedFiles.length === 0) {
+            console.warn(`No file(s) found that satisfy these patterns: ${globPatterns.join(', ')}`);
+        }
+        else {
+            console.warn(`${selectedFiles.length} file(s) found satisfying these patterns: ${globPatterns.join(', ')}`);
+            console.warn({ visiblePaths });
+        }
+    }
+    return { selectedFiles, visiblePaths };
+};
+exports.selectFiles = selectFiles;
+const listAllFiles = (node) => {
+    return node.children.flatMap((child) => child.type === 'file' ? [child] : listAllFiles(child));
+};
+const getVisiblePaths = (selectedFiles) => {
+    const visible = new Set();
+    for (const file of selectedFiles) {
+        visible.add(file.relativePath);
+        const parts = file.relativePath.split('/');
+        let current = '';
+        for (let i = 0; i < parts.length - 1; i++) {
+            current = current ? `${current}/${parts[i]}` : parts[i];
+            visible.add(current);
+        }
+    }
+    return visible;
+};
+exports.getVisiblePaths = getVisiblePaths;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "llmview",
+  "version": "0.1.0",
+  "bin": {
+    "llmview": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "node --test --experimental-strip-types test/**/*.test.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "Generate LLM context from codebases using gitignore-style patterns",
+  "dependencies": {
+    "ignore": "^7.0.5",
+    "minimatch": "^10.0.1"
+  },
+  "devDependencies": {
+    "prettier": "^3.8.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noahtren/llmview.git"
+  },
+  "bugs": {
+    "url": "https://github.com/noahtren/llmview/issues"
+  }
+}