@cliperhq/cliper 1.0.0

package/src/scope/autoScope.ts

@@ -0,0 +1,182 @@
+import simpleGit from "simple-git";
+import * as path from "path";
+import * as fs from "fs";
+import { glob } from "glob";
+
+// Files always included regardless of scope
+const ALWAYS_INCLUDE = [
+  "package.json",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "tsconfig.json",
+  "Cargo.toml",
+  "Cargo.lock",
+  "go.mod",
+  "go.sum",
+  "requirements.txt",
+  "pyproject.toml",
+  "README.md",
+  ".env.example",
+  "docker-compose.yml",
+  "Dockerfile",
+];
+
+type ProjectType = "rust" | "node" | "python" | "go" | "unknown";
+
+function detectProjectType(projectRoot: string): ProjectType {
+  if (fs.existsSync(path.join(projectRoot, "Cargo.toml"))) return "rust";
+  if (fs.existsSync(path.join(projectRoot, "package.json"))) return "node";
+  if (fs.existsSync(path.join(projectRoot, "pyproject.toml")) ||
+      fs.existsSync(path.join(projectRoot, "requirements.txt"))) return "python";
+  if (fs.existsSync(path.join(projectRoot, "go.mod"))) return "go";
+  return "unknown";
+}
+
+function parseRustWorkspaceMembers(projectRoot: string): string[] {
+  const cargoPath = path.join(projectRoot, "Cargo.toml");
+  if (!fs.existsSync(cargoPath)) return [];
+
+  try {
+    const content = fs.readFileSync(cargoPath, "utf-8");
+    // Parse [workspace] members = [...] from Cargo.toml
+    const workspaceMatch = content.match(/\[workspace\][\s\S]*?members\s*=\s*\[([\s\S]*?)\]/);
+    if (!workspaceMatch) return [];
+
+    const membersRaw = workspaceMatch[1];
+    return membersRaw
+      .split(",")
+      .map((m) => m.replace(/["'\s]/g, "").trim())
+      .filter((m) => m.length > 0 && !m.startsWith("#"))
+      .map((m) => m.replace(/\/\*$/, "").replace(/\*$/, "").trim()); // strip glob wildcards
+  } catch {
+    return [];
+  }
+}
+
+async function getRustScope(projectRoot: string): Promise<string[]> {
+  const scope: Set<string> = new Set();
+
+  // Parse workspace members from Cargo.toml
+  const members = parseRustWorkspaceMembers(projectRoot);
+
+  if (members.length > 0) {
+    // It's a workspace — include src/ of each member
+    for (const member of members) {
+      const memberSrc = path.join(member, "src");
+      const fullMemberSrc = path.join(projectRoot, memberSrc);
+      if (fs.existsSync(fullMemberSrc)) {
+        scope.add(memberSrc);
+      }
+      // Also include member Cargo.toml
+      const memberCargo = path.join(member, "Cargo.toml");
+      if (fs.existsSync(path.join(projectRoot, memberCargo))) {
+        scope.add(memberCargo);
+      }
+    }
+  } else {
+    // Single crate — just include src/
+    const srcPath = path.join(projectRoot, "src");
+    if (fs.existsSync(srcPath)) scope.add("src");
+  }
+
+  // Also catch any */src dirs not listed in workspace (safety net)
+  const allSrcDirs = await glob("*/src", {
+    cwd: projectRoot,
+    ignore: ["node_modules/**", ".git/**", "target/**"],
+  });
+  for (const s of allSrcDirs) scope.add(s);
+
+  return Array.from(scope);
+}
+
+async function getNodeScope(projectRoot: string): Promise<string[]> {
+  const scope: Set<string> = new Set();
+  const srcPath = path.join(projectRoot, "src");
+  if (fs.existsSync(srcPath)) scope.add("src");
+
+  // Check for monorepo patterns (packages/, apps/, libs/)
+  for (const dir of ["packages", "apps", "libs"]) {
+    const fullPath = path.join(projectRoot, dir);
+    if (fs.existsSync(fullPath)) scope.add(dir);
+  }
+
+  return Array.from(scope);
+}
+
+async function getPythonScope(projectRoot: string): Promise<string[]> {
+  const scope: Set<string> = new Set();
+  // Python projects typically have a src/ or a package dir matching project name
+  const srcPath = path.join(projectRoot, "src");
+  if (fs.existsSync(srcPath)) scope.add("src");
+
+  // Look for dirs with __init__.py
+  const initFiles = await glob("*/__init__.py", {
+    cwd: projectRoot,
+    ignore: ["node_modules/**", ".git/**", "venv/**", ".venv/**"],
+  });
+  for (const f of initFiles) scope.add(path.dirname(f));
+
+  return Array.from(scope);
+}
+
+async function getGoScope(projectRoot: string): Promise<string[]> {
+  const scope: Set<string> = new Set();
+  const internalPath = path.join(projectRoot, "internal");
+  const pkgPath = path.join(projectRoot, "pkg");
+  const cmdPath = path.join(projectRoot, "cmd");
+  if (fs.existsSync(internalPath)) scope.add("internal");
+  if (fs.existsSync(pkgPath)) scope.add("pkg");
+  if (fs.existsSync(cmdPath)) scope.add("cmd");
+  return Array.from(scope);
+}
+
+export async function autoDetectScope(projectRoot: string): Promise<string[]> {
+  const git = simpleGit(projectRoot);
+  const autoScope: Set<string> = new Set();
+  const projectType = detectProjectType(projectRoot);
+
+  // Step 1: Detect language-specific source dirs
+  let langScope: string[] = [];
+  switch (projectType) {
+    case "rust":   langScope = await getRustScope(projectRoot); break;
+    case "node":   langScope = await getNodeScope(projectRoot); break;
+    case "python": langScope = await getPythonScope(projectRoot); break;
+    case "go":     langScope = await getGoScope(projectRoot); break;
+    default: {
+      const srcPath = path.join(projectRoot, "src");
+      if (fs.existsSync(srcPath)) langScope = ["src"];
+    }
+  }
+  for (const s of langScope) autoScope.add(s);
+
+  // Step 2: Layer git activity on top — add dirs of recently modified files
+  try {
+    const log = await git.raw([
+      "log", "--since=7 days ago", "--name-only", "--pretty=format:", "--diff-filter=AM"
+    ]);
+
+    const recentFiles = log
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0);
+
+    for (const file of recentFiles) {
+      const fullPath = path.join(projectRoot, file);
+      if (fs.existsSync(fullPath)) {
+        const dir = path.dirname(file);
+        if (dir !== ".") autoScope.add(dir);
+      }
+    }
+  } catch {
+    // Not a git repo or no recent commits — lang scope is enough
+  }
+
+  // Step 3: Always include root-level config files
+  for (const file of ALWAYS_INCLUDE) {
+    const fullPath = path.join(projectRoot, file);
+    if (fs.existsSync(fullPath)) autoScope.add(file);
+  }
+
+  return Array.from(autoScope).filter((s) => s !== "." && s.length > 0);
+}

package/src/scope/config.ts

@@ -0,0 +1,39 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export interface ScopeConfig {
+  active: string[];
+  watched: string[];
+  updatedAt: string;
+}
+
+const DEFAULT_CONFIG: ScopeConfig = {
+  active: [],
+  watched: [],
+  updatedAt: new Date().toISOString(),
+};
+
+export function getCliperDir(projectRoot: string): string {
+  return path.join(projectRoot, ".cliper");
+}
+
+export function getScopeConfigPath(projectRoot: string): string {
+  return path.join(getCliperDir(projectRoot), "scope.json");
+}
+
+export function loadScopeConfig(projectRoot: string): ScopeConfig {
+  const configPath = getScopeConfigPath(projectRoot);
+  if (!fs.existsSync(configPath)) return { ...DEFAULT_CONFIG };
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function saveScopeConfig(projectRoot: string, config: ScopeConfig): void {
+  const dir = getCliperDir(projectRoot);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  config.updatedAt = new Date().toISOString();
+  fs.writeFileSync(getScopeConfigPath(projectRoot), JSON.stringify(config, null, 2));
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}