opencode-codeindex 0.1.0 → 0.1.2

package/dist/commands/index.md

@@ -0,0 +1,16 @@
+---
+description: Index current directory with root file contents
+---
+
+Index the current working directory and show:
+
+1. A tree structure of all files and folders
+2. Contents of files at the root level only
+3. Subdirectories show only their structure (no file contents)
+
+Use the tree_indexer tool with:
+
+- path: the current working directory (or '.' if not specified)
+- maxFileSize: 102400 (100KB)
+
+Show the user the formatted markdown output.

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "opencode-codeindex",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "OpenCode plugin that indexes directories with root file contents.",
   "author": {
     "name": "OpenCode",
     "email": "dev@opencode.ai"
   },
   "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -23,8 +26,7 @@
   },
   "files": [
     "dist",
-    "src/version.ts",
-    "src/commands"
+    "src"
   ],
   "scripts": {
     "build": "bunx tsc -p tsconfig.build.json",

package/src/commands/index.md

@@ -1,10 +1,16 @@
 ---
 description: Index current directory with root file contents
-agent: executor
 ---
 
-Use the `tree_indexer` tool to index the current working directory.
-- path: `.`
-- maxFileSize: `102400`
+Index the current working directory and show:
 
-Return the markdown output directly.
+1. A tree structure of all files and folders
+2. Contents of files at the root level only
+3. Subdirectories show only their structure (no file contents)
+
+Use the tree_indexer tool with:
+
+- path: the current working directory (or '.' if not specified)
+- maxFileSize: 102400 (100KB)
+
+Show the user the formatted markdown output.

package/src/index.ts

@@ -0,0 +1,130 @@
+import type { Plugin } from '@opencode-ai/plugin';
+import { tool } from '@opencode-ai/plugin';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { buildTree } from './lib/tree-builder';
+import { readFileContent } from './lib/file-reader';
+import { formatOutput } from './lib/output-formatter';
+
+interface CommandFrontmatter {
+  description?: string;
+  agent?: string;
+  model?: string;
+  subtask?: boolean;
+}
+
+interface ParsedCommand {
+  name: string;
+  frontmatter: CommandFrontmatter;
+  template: string;
+}
+
+interface IndexArgs {
+  path: string;
+  maxFileSize?: number;
+}
+
+function parseFrontmatter(content: string): { frontmatter: CommandFrontmatter; body: string } {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+
+  if (!match) {
+    return { frontmatter: {}, body: content.trim() };
+  }
+
+  const [, yamlContent, body] = match;
+  const frontmatter: CommandFrontmatter = {};
+
+  for (const line of yamlContent.split('\n')) {
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1) continue;
+
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+
+    if (key === 'description') frontmatter.description = value;
+    if (key === 'agent') frontmatter.agent = value;
+    if (key === 'model') frontmatter.model = value;
+    if (key === 'subtask') frontmatter.subtask = value === 'true';
+  }
+
+  return { frontmatter, body: body.trim() };
+}
+
+async function loadCommands(): Promise<ParsedCommand[]> {
+  const commands: ParsedCommand[] = [];
+  const commandDir = path.join(import.meta.dir, 'commands');
+  const glob = new Bun.Glob('**/*.md');
+
+  for await (const file of glob.scan({ cwd: commandDir, absolute: true })) {
+    const content = await Bun.file(file).text();
+    const { frontmatter, body } = parseFrontmatter(content);
+
+    const relativePath = path.relative(commandDir, file);
+    const name = relativePath.replace(/\.md$/, '').replace(/\//g, '-');
+
+    commands.push({
+      name,
+      frontmatter,
+      template: body,
+    });
+  }
+
+  return commands;
+}
+
+export async function indexDirectory(args: IndexArgs): Promise<string> {
+  const targetPath = path.resolve(args.path);
+  const stat = await fs.stat(targetPath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Path is not a directory: ${targetPath}`);
+  }
+
+  const tree = await buildTree(targetPath);
+  const rootFiles = (tree.children ?? []).filter((node) => node.type === 'file');
+
+  for (const file of rootFiles) {
+    const result = await readFileContent(file.path, args.maxFileSize);
+    file.content = result.content;
+    if (result.error) file.error = result.error;
+    file.size = result.size;
+  }
+
+  return formatOutput(tree, targetPath);
+}
+
+export const CodeIndexPlugin: Plugin = async () => {
+  const commands = await loadCommands();
+
+  const treeIndexerTool = tool({
+    description: 'Generate a directory tree with root file contents',
+    args: {
+      path: tool.schema.string().describe('Root path to index'),
+      maxFileSize: tool.schema.number().optional().describe('Max file size in bytes'),
+    },
+    async execute(args) {
+      return indexDirectory({
+        path: args.path,
+        maxFileSize: args.maxFileSize,
+      });
+    },
+  });
+
+  return {
+    tool: {
+      tree_indexer: treeIndexerTool,
+    },
+    async config(config) {
+      config.command = config.command ?? {};
+      for (const cmd of commands) {
+        config.command[cmd.name] = {
+          template: cmd.template,
+          description: cmd.frontmatter.description,
+          agent: cmd.frontmatter.agent,
+          model: cmd.frontmatter.model,
+          subtask: cmd.frontmatter.subtask,
+        };
+      }
+    },
+  };
+};

package/src/lib/file-reader.ts

@@ -0,0 +1,73 @@
+import fs from 'node:fs/promises';
+import isBinaryPath from 'is-binary-path';
+
+export interface FileReadResult {
+  content: string;
+  size: number;
+  error?: string;
+}
+
+const DEFAULT_MAX_FILE_SIZE = 100 * 1024;
+const PROBE_LENGTH = 8000;
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+async function readProbe(filePath: string): Promise<Buffer> {
+  const handle = await fs.open(filePath, 'r');
+  try {
+    const buffer = Buffer.alloc(PROBE_LENGTH);
+    const { bytesRead } = await handle.read(buffer, 0, PROBE_LENGTH, 0);
+    return buffer.subarray(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+
+function isBinaryBuffer(buffer: Buffer): boolean {
+  return buffer.includes(0);
+}
+
+function formatError(err: unknown, fallback: string): string {
+  if (err && typeof err === 'object' && 'code' in err) {
+    const code = String((err as { code?: string }).code ?? '');
+    if (code === 'EACCES' || code === 'EPERM') return 'Permission denied';
+  }
+  if (err instanceof Error) return err.message;
+  return fallback;
+}
+
+export async function readFileContent(
+  filePath: string,
+  maxFileSize: number = DEFAULT_MAX_FILE_SIZE
+): Promise<FileReadResult> {
+  try {
+    const stat = await fs.stat(filePath);
+    const size = stat.size;
+
+    if (size > maxFileSize) {
+      return {
+        size,
+        content: `[File too large: ${formatSize(size)}]`,
+        error: 'File too large',
+      };
+    }
+
+    const probe = await readProbe(filePath);
+    if (isBinaryPath(filePath) || isBinaryBuffer(probe)) {
+      return { size, content: '[Binary file]', error: 'Binary file' };
+    }
+
+    const content = await fs.readFile(filePath, 'utf8');
+    return { size, content };
+  } catch (err) {
+    return {
+      size: 0,
+      content: `[${formatError(err, 'Read error')}]`,
+      error: formatError(err, 'Read error'),
+    };
+  }
+}

package/src/lib/output-formatter.ts

@@ -0,0 +1,83 @@
+import path from 'node:path';
+import type { TreeNode } from './tree-builder';
+
+function formatSize(bytes?: number): string {
+  if (bytes === undefined) return '';
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function formatLanguage(filename: string): string {
+  const ext = path.extname(filename).toLowerCase();
+  if (ext === '.md') return 'markdown';
+  if (ext === '.json') return 'json';
+  if (ext === '.ts') return 'typescript';
+  if (ext === '.tsx') return 'tsx';
+  if (ext === '.js') return 'javascript';
+  if (ext === '.yml' || ext === '.yaml') return 'yaml';
+  return 'text';
+}
+
+function renderTree(root: TreeNode): string[] {
+  const lines: string[] = [];
+  const rootLabel = `${path.basename(root.path) || root.path}/`;
+  lines.push(rootLabel);
+
+  const children = root.children ?? [];
+  const renderChildren = (nodes: TreeNode[], prefix: string) => {
+    nodes.forEach((node, index) => {
+      const isLast = index === nodes.length - 1;
+      const connector = isLast ? '└── ' : '├── ';
+      const name = node.type === 'directory' ? `${node.name}/` : node.name;
+      const size = node.type === 'file' ? ` (${formatSize(node.size)})` : '';
+      const error = node.error ? ` [${node.error}]` : '';
+      lines.push(`${prefix}${connector}${name}${size}${error}`);
+
+      if (node.type === 'directory' && node.children && node.children.length > 0) {
+        const nextPrefix = prefix + (isLast ? '    ' : '│   ');
+        renderChildren(node.children, nextPrefix);
+      }
+    });
+  };
+
+  const ordered = [...children].sort((a, b) => {
+    if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  renderChildren(ordered, '');
+
+  return lines;
+}
+
+export function formatOutput(root: TreeNode, rootPath: string): string {
+  const lines: string[] = [];
+  lines.push(`# Directory Index: ${rootPath}`);
+  lines.push('');
+  lines.push('## File Structure');
+  lines.push('');
+  lines.push('```');
+  lines.push(...renderTree(root));
+  lines.push('```');
+  lines.push('');
+  lines.push('## Root Level Files');
+  lines.push('');
+
+  const rootFiles = (root.children ?? []).filter((node) => node.type === 'file');
+  if (rootFiles.length === 0) {
+    lines.push('_No root-level files found._');
+    return lines.join('\n');
+  }
+
+  for (const file of rootFiles) {
+    const content = file.content ?? (file.error ? `[${file.error}]` : '[No content]');
+    const language = formatLanguage(file.name);
+    lines.push(`### ${file.name}`);
+    lines.push('```' + language);
+    lines.push(content);
+    lines.push('```');
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}

package/src/lib/tree-builder.ts

@@ -0,0 +1,195 @@
+import fs from 'node:fs/promises';
+import type { Dirent } from 'node:fs';
+import path from 'node:path';
+import ignore, { type Ignore } from 'ignore';
+
+export interface TreeNode {
+  name: string;
+  path: string;
+  type: 'file' | 'directory';
+  depth: number;
+  children?: TreeNode[];
+  content?: string;
+  size?: number;
+  error?: string;
+}
+
+export interface TreeBuilderOptions {
+  skipNames?: string[];
+  skipExtensions?: string[];
+  respectGitignore?: boolean;
+}
+
+export const DEFAULT_SKIP_NAMES = new Set([
+  '.git',
+  'node_modules',
+  '.opencode',
+  'dist',
+  'build',
+]);
+
+const DEFAULT_SKIP_EXTENSIONS = new Set(['.log']);
+
+function normalizeGitignorePath(relativePath: string): string {
+  return relativePath.split(path.sep).join('/');
+}
+
+function formatError(err: unknown, fallback: string): string {
+  if (err && typeof err === 'object' && 'code' in err) {
+    const code = String((err as { code?: string }).code ?? '');
+    if (code === 'EACCES' || code === 'EPERM') return 'Permission denied';
+    if (code === 'ENOENT') return 'Path not found';
+  }
+  if (err instanceof Error) return err.message;
+  return fallback;
+}
+
+async function loadGitignore(rootPath: string, enabled: boolean): Promise<Ignore | null> {
+  if (!enabled) return null;
+  const gitignorePath = path.join(rootPath, '.gitignore');
+  try {
+    const content = await fs.readFile(gitignorePath, 'utf8');
+    return ignore().add(content);
+  } catch {
+    return null;
+  }
+}
+
+function shouldSkip(
+  name: string,
+  skipNames: Set<string>,
+  skipExtensions: Set<string>
+): boolean {
+  if (skipNames.has(name)) return true;
+  for (const ext of skipExtensions) {
+    if (name.endsWith(ext)) return true;
+  }
+  return false;
+}
+
+async function walkDirectory(
+  absolutePath: string,
+  relativePath: string,
+  depth: number,
+  ignoreRules: Ignore | null,
+  skipNames: Set<string>,
+  skipExtensions: Set<string>,
+  visited: Set<string>
+): Promise<TreeNode[]> {
+  let entries: Dirent[] = [];
+  try {
+    entries = await fs.readdir(absolutePath, { withFileTypes: true });
+  } catch (err) {
+    return [
+      {
+        name: path.basename(absolutePath),
+        path: absolutePath,
+        type: 'directory',
+        depth,
+        error: formatError(err, 'Read error'),
+      },
+    ];
+  }
+
+  const nodes: TreeNode[] = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (shouldSkip(entry.name, skipNames, skipExtensions)) continue;
+
+    const entryPath = path.join(absolutePath, entry.name);
+    const entryRelative = normalizeGitignorePath(path.join(relativePath, entry.name));
+    if (ignoreRules?.ignores(entryRelative)) continue;
+
+    try {
+      const stat = await fs.lstat(entryPath);
+
+      if (stat.isSymbolicLink()) {
+        const resolved = await fs.realpath(entryPath);
+        const resolvedStat = await fs.stat(entryPath);
+        if (resolvedStat.isDirectory()) {
+          if (visited.has(resolved)) {
+            nodes.push({
+              name: entry.name,
+              path: entryPath,
+              type: 'directory',
+              depth,
+              error: 'Circular reference',
+            });
+            continue;
+          }
+          visited.add(resolved);
+        }
+      }
+
+      if (stat.isDirectory()) {
+        const children = await walkDirectory(
+          entryPath,
+          entryRelative,
+          depth + 1,
+          ignoreRules,
+          skipNames,
+          skipExtensions,
+          visited
+        );
+        nodes.push({
+          name: entry.name,
+          path: entryPath,
+          type: 'directory',
+          depth,
+          children,
+        });
+      } else {
+        nodes.push({
+          name: entry.name,
+          path: entryPath,
+          type: 'file',
+          depth,
+          size: stat.size,
+        });
+      }
+    } catch (err) {
+      nodes.push({
+        name: entry.name,
+        path: entryPath,
+        type: entry.isDirectory() ? 'directory' : 'file',
+        depth,
+        error: formatError(err, 'Read error'),
+      });
+    }
+  }
+
+  return nodes;
+}
+
+export async function buildTree(
+  rootPath: string,
+  options: TreeBuilderOptions = {}
+): Promise<TreeNode> {
+  const resolvedRoot = path.resolve(rootPath);
+  const stat = await fs.stat(resolvedRoot);
+  if (!stat.isDirectory()) {
+    throw new Error(`Path is not a directory: ${resolvedRoot}`);
+  }
+
+  const ignoreRules = await loadGitignore(resolvedRoot, options.respectGitignore !== false);
+  const skipNames = new Set(options.skipNames ?? Array.from(DEFAULT_SKIP_NAMES));
+  const skipExtensions = new Set(options.skipExtensions ?? Array.from(DEFAULT_SKIP_EXTENSIONS));
+  const visited = new Set<string>([resolvedRoot]);
+
+  const children = await walkDirectory(
+    resolvedRoot,
+    '',
+    0,
+    ignoreRules,
+    skipNames,
+    skipExtensions,
+    visited
+  );
+
+  return {
+    name: path.basename(resolvedRoot) || resolvedRoot,
+    path: resolvedRoot,
+    type: 'directory',
+    depth: -1,
+    children,
+  };
+}