@cliperhq/cliper 1.0.0

package/src/scanner/dependencies.ts

@@ -0,0 +1,196 @@
+import * as fs from "fs";
+import * as path from "path";
+import { FileContent } from "./fileContent";
+
+export interface DependencyEdge {
+    from: string;
+    to: string;
+    type: "import" | "require" | "use" | "mod";
+}
+
+export interface DependencyMap {
+    edges: DependencyEdge[];
+    externalPackages: string[];
+    entryPoints: string[];
+}
+
+function extractJSImports(file: FileContent): { internal: string[]; external: string[] } {
+    const internal: string[] = [];
+    const external: string[] = [];
+
+    const patterns = [
+        /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
+        /require\(['"]([^'"]+)['"]\)/g,
+        /import\(['"]([^'"]+)['"]\)/g,
+    ];
+
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(file.content)) !== null) {
+            const dep = match[1];
+            if (dep.startsWith(".") || dep.startsWith("/")) {
+                const dir = path.dirname(file.relativePath);
+                const resolved = path.normalize(path.join(dir, dep));
+                internal.push(resolved);
+            } else {
+                const pkgName = dep.startsWith("@")
+                    ? dep.split("/").slice(0, 2).join("/")
+                    : dep.split("/")[0];
+                external.push(pkgName);
+            }
+        }
+    }
+
+    return { internal, external };
+}
+
+function extractRustImports(file: FileContent): { internal: string[]; external: string[] } {
+    const internal: string[] = [];
+    const external: string[] = [];
+
+    const usePattern = /^use\s+([\w:]+)/gm;
+    const modPattern = /^(?:pub\s+)?mod\s+(\w+)/gm;
+
+    let match;
+    while ((match = usePattern.exec(file.content)) !== null) {
+        const dep = match[1];
+        if (dep.startsWith("crate::") || dep.startsWith("super::") || dep.startsWith("self::")) {
+            internal.push(dep.replace(/^(crate|super|self)::/, ""));
+        } else {
+            external.push(dep.split("::")[0]);
+        }
+    }
+
+    while ((match = modPattern.exec(file.content)) !== null) {
+        internal.push(match[1]);
+    }
+
+    return { internal, external };
+}
+
+function extractPythonImports(file: FileContent): { internal: string[]; external: string[] } {
+    const internal: string[] = [];
+    const external: string[] = [];
+
+    const relPattern = /^from\s+(\.+[\w.]*)\s+import/gm;
+    const absPatterns = [
+        /^import\s+([\w.]+)/gm,
+        /^from\s+([\w.]+)\s+import/gm,
+    ];
+
+    let match;
+    while ((match = relPattern.exec(file.content)) !== null) {
+        internal.push(match[1]);
+    }
+
+    for (const pattern of absPatterns) {
+        while ((match = pattern.exec(file.content)) !== null) {
+            external.push(match[1].split(".")[0]);
+        }
+    }
+
+    return { internal, external };
+}
+
+function getExtractor(filePath: string) {
+    const ext = path.extname(filePath).toLowerCase();
+    if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) return extractJSImports;
+    if (ext === ".rs") return extractRustImports;
+    if (ext === ".py") return extractPythonImports;
+    return null;
+}
+
+function isEntryPoint(filePath: string): boolean {
+    const name = path.basename(filePath);
+    return [
+        "index.ts", "index.js", "main.ts", "main.js",
+        "main.rs", "lib.rs",
+        "main.py", "__init__.py",
+        "main.go",
+    ].includes(name);
+}
+
+export function buildDependencyMap(files: FileContent[]): DependencyMap {
+    const edges: DependencyEdge[] = [];
+    const externalSet = new Set<string>();
+    const entryPoints: string[] = [];
+
+    for (const file of files) {
+        if (file.truncated) continue;
+
+        const extractor = getExtractor(file.relativePath);
+        if (!extractor) continue;
+
+        if (isEntryPoint(file.relativePath)) {
+            entryPoints.push(file.relativePath);
+        }
+
+        const { internal, external } = extractor(file);
+
+        for (const dep of internal) {
+            edges.push({
+                from: file.relativePath,
+                to: dep,
+                type: file.relativePath.endsWith(".rs") ? "use" : "import",
+            });
+        }
+
+        for (const pkg of external) {
+            externalSet.add(pkg);
+        }
+    }
+
+    const seen = new Set<string>();
+    const uniqueEdges = edges.filter((e) => {
+        const key = `${e.from}→${e.to}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+    });
+
+    return {
+        edges: uniqueEdges,
+        externalPackages: Array.from(externalSet).sort(),
+        entryPoints,
+    };
+}
+
+export function formatDependencyMap(map: DependencyMap): string {
+    if (map.edges.length === 0 && map.externalPackages.length === 0) {
+        return "No dependency information available for scoped files.";
+    }
+
+    const lines: string[] = [];
+
+    if (map.entryPoints.length > 0) {
+        lines.push("**Entry points:**");
+        for (const ep of map.entryPoints) {
+            lines.push(`  → ${ep}`);
+        }
+        lines.push("");
+    }
+
+    if (map.edges.length > 0) {
+        lines.push("**Internal dependencies:**");
+        const byFile = new Map<string, string[]>();
+        for (const edge of map.edges) {
+            if (!byFile.has(edge.from)) byFile.set(edge.from, []);
+            byFile.get(edge.from)!.push(edge.to);
+        }
+        for (const [from, deps] of byFile) {
+            lines.push(`  ${from}`);
+            for (const dep of deps.slice(0, 8)) {
+                lines.push(`    ↳ ${dep}`);
+            }
+            if (deps.length > 8) lines.push(`    ↳ ... and ${deps.length - 8} more`);
+        }
+        lines.push("");
+    }
+
+    if (map.externalPackages.length > 0) {
+        lines.push("**External packages used:**");
+        lines.push(`  ${map.externalPackages.join(", ")}`);
+    }
+
+    return lines.join("\n");
+}

package/src/scanner/fileContent.ts

@@ -0,0 +1,121 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+import ignore from "ignore";
+
+
+const MAX_TOTAL_CHARS = 150_000;
+
+const BINARY_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".webp",
+  ".pdf", ".zip", ".tar", ".gz", ".exe", ".bin", ".wasm",
+  ".ttf", ".woff", ".woff2", ".eot", ".mp4", ".mp3",
+]);
+
+const PRIORITY_EXTENSIONS = [
+  ".ts", ".tsx", ".js", ".jsx", ".py", ".rs", ".go",
+  ".java", ".kt", ".swift", ".rb", ".php", ".cs",
+  ".json", ".yaml", ".yml", ".toml", ".env.example",
+  ".md", ".mdx", ".sql", ".graphql", ".prisma",
+];
+
+function isBinary(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+
+function getPriority(filePath: string): number {
+  const ext = path.extname(filePath).toLowerCase();
+  const idx = PRIORITY_EXTENSIONS.indexOf(ext);
+  return idx === -1 ? 999 : idx;
+}
+
+
+
+export interface FileContent {
+  relativePath: string;
+  content: string;
+  truncated: boolean;
+  size: number;
+}
+
+export async function extractFileContents(
+  projectRoot: string,
+  activeScope: string[],
+  watchedScope: string[],
+  maxFileSizeKB: number = 50
+): Promise<FileContent[]> {
+  const MAX_FILE_SIZE_BYTES = maxFileSizeKB * 1024;
+  const ig = ignore();
+  const gitignorePath = path.join(projectRoot, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    ig.add(fs.readFileSync(gitignorePath, "utf-8"));
+  }
+
+  const allPaths = new Set<string>();
+
+  // Collect files from active scope and watched scope
+  for (const scopePath of [...activeScope, ...watchedScope]) {
+    const fullScopePath = path.join(projectRoot, scopePath);
+    if (!fs.existsSync(fullScopePath)) continue;
+
+    const stat = fs.statSync(fullScopePath);
+    if (stat.isFile()) {
+      allPaths.add(scopePath);
+    } else if (stat.isDirectory()) {
+      const files = await glob("**/*", {
+        cwd: fullScopePath,
+        nodir: true,
+        ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
+      });
+      for (const f of files) {
+        const rel = path.join(scopePath, f);
+        if (!ig.ignores(rel)) allPaths.add(rel);
+      }
+    }
+  }
+
+  // Sort by priority
+  const sortedPaths = Array.from(allPaths).sort(
+    (a, b) => getPriority(a) - getPriority(b)
+  );
+
+  const results: FileContent[] = [];
+  let totalChars = 0;
+
+  for (const relativePath of sortedPaths) {
+    if (totalChars >= MAX_TOTAL_CHARS) break;
+    if (isBinary(relativePath)) continue;
+
+    const fullPath = path.join(projectRoot, relativePath);
+    if (!fs.existsSync(fullPath)) continue;
+
+    const stat = fs.statSync(fullPath);
+    if (stat.size > MAX_FILE_SIZE_BYTES) {
+      results.push({
+        relativePath,
+        content: `[File too large to include: ${Math.round(stat.size / 1024)}KB]`,
+        truncated: true,
+        size: stat.size,
+      });
+      continue;
+    }
+
+    try {
+      let content = fs.readFileSync(fullPath, "utf-8");
+      let truncated = false;
+
+      if (totalChars + content.length > MAX_TOTAL_CHARS) {
+        content = content.slice(0, MAX_TOTAL_CHARS - totalChars);
+        truncated = true;
+      }
+
+      totalChars += content.length;
+      results.push({ relativePath, content, truncated, size: stat.size });
+    } catch {
+      // Skip files that can't be read
+    }
+  }
+
+  return results;
+}

package/src/scanner/fileTree.ts

@@ -0,0 +1,149 @@
+import * as fs from "fs";
+import * as path from "path";
+import ignore from "ignore";
+
+const IGNORE_DIRS = new Set([
+  "node_modules", ".git", "dist", "build", ".next", ".nuxt",
+  "coverage", ".cache", "__pycache__", ".pytest_cache", "vendor",
+  ".cliper",
+]);
+
+interface TreeNode {
+  name: string;
+  isDir: boolean;
+  children?: TreeNode[];
+  inScope: boolean;
+  watched: boolean;
+  relativePath: string;
+  modifiedAt?: Date;
+}
+
+function loadGitignore(projectRoot: string) {
+  const ig = ignore();
+  const gitignorePath = path.join(projectRoot, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    ig.add(fs.readFileSync(gitignorePath, "utf-8"));
+  }
+  return ig;
+}
+
+function getModifiedTime(filePath: string): Date | undefined {
+  try {
+    return fs.statSync(filePath).mtime;
+  } catch {
+    return undefined;
+  }
+}
+
+function buildTree(
+  dirPath: string,
+  projectRoot: string,
+  activeScope: string[],
+  watchedScope: string[],
+  ig: ReturnType<typeof ignore>,
+  depth = 0,
+  maxDepth = 4
+): TreeNode[] {
+  if (depth > maxDepth) return [];
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const nodes: TreeNode[] = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const relativePath = path.relative(projectRoot, fullPath);
+
+    if (IGNORE_DIRS.has(entry.name)) continue;
+    if (ig.ignores(relativePath)) continue;
+    if (entry.name.startsWith(".") && entry.name !== ".env.example") continue;
+
+    const inScope = activeScope.some(
+      (s) => relativePath.startsWith(s) || s.startsWith(relativePath)
+    );
+    const watched = watchedScope.some(
+      (s) => relativePath.startsWith(s) || relativePath === s
+    );
+
+    const node: TreeNode = {
+      name: entry.name,
+      isDir: entry.isDirectory(),
+      inScope,
+      watched,
+      relativePath,
+      modifiedAt: entry.isFile() ? getModifiedTime(fullPath) : undefined,
+    };
+
+    if (entry.isDirectory()) {
+      node.children = buildTree(
+        fullPath, projectRoot, activeScope, watchedScope, ig, depth + 1, maxDepth
+      );
+    }
+
+    nodes.push(node);
+  }
+
+  return nodes.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+
+function formatTimeAgo(date: Date): string {
+  const diff = Date.now() - date.getTime();
+  const mins = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+  if (mins < 60) return `${mins}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  return `${days}d ago`;
+}
+
+function renderTree(nodes: TreeNode[], prefix = "", isRoot = false): string {
+  const lines: string[] = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const isLast = i === nodes.length - 1;
+    const connector = isLast ? "└── " : "├── ";
+    const childPrefix = prefix + (isLast ? "    " : "│   ");
+
+    let annotation = "";
+    if (node.inScope) annotation += " ← ACTIVE SCOPE";
+    else if (node.watched) annotation += " ← WATCHED";
+
+    let timeAnnotation = "";
+    if (node.modifiedAt && !node.isDir) {
+      timeAnnotation = ` (${formatTimeAgo(node.modifiedAt)})`;
+    }
+
+    if (node.isDir && !node.inScope && !node.watched && !isRoot) {
+      const childCount = node.children?.length ?? 0;
+      lines.push(`${prefix}${connector}${node.name}/${annotation || ` ← out of scope (${childCount} items)`}`);
+    } else {
+      lines.push(`${prefix}${connector}${node.name}${node.isDir ? "/" : ""}${annotation}${timeAnnotation}`);
+      if (node.children && node.children.length > 0 && (node.inScope || node.watched || isRoot)) {
+        lines.push(renderTree(node.children, childPrefix));
+      }
+    }
+  }
+
+  return lines.filter(Boolean).join("\n");
+}
+
+export function generateFileTree(
+  projectRoot: string,
+  activeScope: string[],
+  watchedScope: string[]
+): string {
+  const ig = loadGitignore(projectRoot);
+  const projectName = path.basename(projectRoot);
+  const nodes = buildTree(projectRoot, projectRoot, activeScope, watchedScope, ig, 0);
+  const tree = renderTree(nodes, "", true);
+  return `${projectName}/\n${tree}`;
+}

package/src/scanner/gitContext.ts

@@ -0,0 +1,74 @@
+import simpleGit from "simple-git";
+
+export interface GitContext {
+  branch: string;
+  lastCommit: {
+    hash: string;
+    message: string;
+    author: string;
+    date: string;
+    timeAgo: string;
+  } | null;
+  recentCommits: Array<{
+    hash: string;
+    message: string;
+    date: string;
+  }>;
+  uncommittedChanges: string[];
+  isGitRepo: boolean;
+}
+
+function timeAgo(dateStr: string): string {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+  if (mins < 60) return `${mins} minutes ago`;
+  if (hours < 24) return `${hours} hours ago`;
+  return `${days} days ago`;
+}
+
+export async function getGitContext(projectRoot: string): Promise<GitContext> {
+  const git = simpleGit(projectRoot);
+
+  try {
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      return { branch: "", lastCommit: null, recentCommits: [], uncommittedChanges: [], isGitRepo: false };
+    }
+
+    const [branch, log, status] = await Promise.all([
+      git.revparse(["--abbrev-ref", "HEAD"]),
+      git.log({ maxCount: 5 }),
+      git.status(),
+    ]);
+
+    const [latest, ...rest] = log.all;
+
+    return {
+      isGitRepo: true,
+      branch: branch.trim(),
+      lastCommit: latest
+        ? {
+            hash: latest.hash.slice(0, 7),
+            message: latest.message,
+            author: latest.author_name,
+            date: latest.date,
+            timeAgo: timeAgo(latest.date),
+          }
+        : null,
+      recentCommits: rest.map((c) => ({
+        hash: c.hash.slice(0, 7),
+        message: c.message,
+        date: c.date,
+      })),
+      uncommittedChanges: [
+        ...status.modified,
+        ...status.created,
+        ...status.deleted,
+      ],
+    };
+  } catch {
+    return { branch: "", lastCommit: null, recentCommits: [], uncommittedChanges: [], isGitRepo: false };
+  }
+}