@hienlh/ppm 0.1.0

package/src/services/git.service.ts

@@ -0,0 +1,372 @@
+import simpleGit, { type SimpleGit } from "simple-git";
+import type {
+  GitStatus,
+  GitFileChange,
+  GitCommit,
+  GitBranch,
+  GitGraphData,
+} from "../types/git.ts";
+
+class GitService {
+  private git(projectPath: string): SimpleGit {
+    return simpleGit(projectPath);
+  }
+
+  async status(projectPath: string): Promise<GitStatus> {
+    const git = this.git(projectPath);
+    const s = await git.status();
+
+    const staged: GitFileChange[] = [];
+    for (const f of s.staged) {
+      staged.push({ path: f, status: "M" });
+    }
+    for (const f of s.created) {
+      if (s.staged.includes(f)) {
+        // Override status for staged created files
+        const idx = staged.findIndex((x) => x.path === f);
+        if (idx >= 0) staged[idx]!.status = "A";
+        else staged.push({ path: f, status: "A" });
+      }
+    }
+    for (const f of s.deleted) {
+      if (s.staged.includes(f)) {
+        const idx = staged.findIndex((x) => x.path === f);
+        if (idx >= 0) staged[idx]!.status = "D";
+        else staged.push({ path: f, status: "D" });
+      }
+    }
+    for (const f of s.renamed) {
+      staged.push({ path: f.to, status: "R", oldPath: f.from });
+    }
+
+    // Build staged set from the raw diff result for accuracy
+    const stagedSet = new Set<string>();
+    const stagedFiles: GitFileChange[] = [];
+    try {
+      const diffStaged = await git.diff(["--cached", "--name-status"]);
+      for (const line of diffStaged.trim().split("\n")) {
+        if (!line) continue;
+        const parts = line.split("\t");
+        const statusChar = (parts[0] ?? "M").charAt(0) as GitFileChange["status"];
+        const filePath = parts[1] ?? "";
+        const oldPath = statusChar === "R" ? filePath : undefined;
+        const actualPath = statusChar === "R" ? (parts[2] ?? filePath) : filePath;
+        stagedSet.add(actualPath);
+        stagedFiles.push({ path: actualPath, status: statusChar, oldPath });
+      }
+    } catch {
+      // Fallback: empty repo or no HEAD
+    }
+
+    // Unstaged changes
+    const unstaged: GitFileChange[] = [];
+    try {
+      const diffUnstaged = await git.diff(["--name-status"]);
+      for (const line of diffUnstaged.trim().split("\n")) {
+        if (!line) continue;
+        const parts = line.split("\t");
+        const statusChar = (parts[0] ?? "M").charAt(0) as GitFileChange["status"];
+        const filePath = parts[1] ?? "";
+        const oldPath = statusChar === "R" ? filePath : undefined;
+        const actualPath = statusChar === "R" ? (parts[2] ?? filePath) : filePath;
+        unstaged.push({ path: actualPath, status: statusChar, oldPath });
+      }
+    } catch {
+      // empty
+    }
+
+    // Untracked files (not in staged)
+    const untracked = s.not_added.filter((f) => !stagedSet.has(f));
+
+    return {
+      current: s.current,
+      staged: stagedFiles.length > 0 ? stagedFiles : staged,
+      unstaged,
+      untracked,
+    };
+  }
+
+  async diff(
+    projectPath: string,
+    ref1?: string,
+    ref2?: string,
+  ): Promise<string> {
+    const git = this.git(projectPath);
+    const args: string[] = [];
+    if (ref1) args.push(ref1);
+    if (ref2) args.push(ref2);
+    return git.diff(args);
+  }
+
+  async diffStat(
+    projectPath: string,
+    ref1?: string,
+    ref2?: string,
+  ): Promise<Array<{ path: string; additions: number; deletions: number }>> {
+    const git = this.git(projectPath);
+    const args: string[] = ["--numstat"];
+    if (ref1) args.push(ref1);
+    if (ref2) args.push(ref2);
+    const raw = await git.diff(args);
+    const files: Array<{ path: string; additions: number; deletions: number }> = [];
+    for (const line of raw.trim().split("\n")) {
+      if (!line) continue;
+      const parts = line.split("\t");
+      const additions = parseInt(parts[0] ?? "0", 10) || 0;
+      const deletions = parseInt(parts[1] ?? "0", 10) || 0;
+      const path = parts[2] ?? "";
+      if (path) files.push({ path, additions, deletions });
+    }
+    return files;
+  }
+
+  async fileDiff(
+    projectPath: string,
+    filePath: string,
+    ref?: string,
+  ): Promise<string> {
+    const git = this.git(projectPath);
+    const args: string[] = [];
+    if (ref) args.push(ref);
+    args.push("--", filePath);
+    return git.diff(args);
+  }
+
+  async stage(projectPath: string, files: string[]): Promise<void> {
+    await this.git(projectPath).add(files);
+  }
+
+  async unstage(projectPath: string, files: string[]): Promise<void> {
+    await this.git(projectPath).reset(["HEAD", "--", ...files]);
+  }
+
+  async commit(projectPath: string, message: string): Promise<string> {
+    const result = await this.git(projectPath).commit(message);
+    return result.commit;
+  }
+
+  async push(
+    projectPath: string,
+    remote?: string,
+    branch?: string,
+  ): Promise<void> {
+    const args: string[] = [];
+    if (remote) args.push(remote);
+    if (branch) args.push(branch);
+    await this.git(projectPath).push(args);
+  }
+
+  async pull(
+    projectPath: string,
+    remote?: string,
+    branch?: string,
+  ): Promise<void> {
+    const args: string[] = [];
+    if (remote) args.push(remote);
+    if (branch) args.push(branch);
+    await this.git(projectPath).pull(args);
+  }
+
+  async branches(projectPath: string): Promise<GitBranch[]> {
+    const git = this.git(projectPath);
+    const summary = await git.branch(["-a", "--no-color"]);
+    return Object.entries(summary.branches).map(([name, info]) => ({
+      name,
+      current: info.current,
+      remote: name.startsWith("remotes/"),
+      commitHash: info.commit,
+      ahead: 0,
+      behind: 0,
+    }));
+  }
+
+  async createBranch(
+    projectPath: string,
+    name: string,
+    from?: string,
+  ): Promise<void> {
+    const args = [name];
+    if (from) args.push(from);
+    await this.git(projectPath).checkoutBranch(name, from ?? "HEAD");
+  }
+
+  async checkout(projectPath: string, ref: string): Promise<void> {
+    await this.git(projectPath).checkout(ref);
+  }
+
+  async deleteBranch(
+    projectPath: string,
+    name: string,
+    force = false,
+  ): Promise<void> {
+    const flag = force ? "-D" : "-d";
+    await this.git(projectPath).branch([flag, name]);
+  }
+
+  async merge(projectPath: string, source: string): Promise<void> {
+    await this.git(projectPath).merge([source]);
+  }
+
+  async graphData(
+    projectPath: string,
+    maxCount = 200,
+  ): Promise<GitGraphData> {
+    const git = this.git(projectPath);
+
+    // Use simple-git built-in log
+    const log = await git.log({ "--all": null, maxCount });
+
+    const commits: GitCommit[] = log.all.map((c) => ({
+      hash: c.hash,
+      abbreviatedHash: c.hash.slice(0, 7),
+      subject: c.message,
+      body: c.body,
+      authorName: c.author_name,
+      authorEmail: c.author_email,
+      authorDate: c.date,
+      parents: [],
+      refs: c.refs ? c.refs.split(", ").filter(Boolean) : [],
+    }));
+
+    // Get parent hashes via raw format
+    try {
+      const parentLog = await git.raw([
+        "log",
+        "--all",
+        `--max-count=${maxCount}`,
+        "--format=%H %P",
+      ]);
+      const parentMap = new Map<string, string[]>();
+      for (const line of parentLog.trim().split("\n")) {
+        if (!line) continue;
+        const [hash, ...parents] = line.split(" ");
+        if (hash) parentMap.set(hash, parents.filter(Boolean));
+      }
+      for (const c of commits) {
+        c.parents = parentMap.get(c.hash) ?? [];
+      }
+    } catch {
+      // May fail on empty repo
+    }
+
+    const branchSummary = await git.branch(["-a", "--no-color"]);
+
+    // simple-git branch().commit returns abbreviated hash — map to full hash
+    const abbrToFull = new Map<string, string>();
+    for (const c of commits) {
+      abbrToFull.set(c.abbreviatedHash, c.hash);
+      // Also index with longer prefixes for safety
+      abbrToFull.set(c.hash.slice(0, 8), c.hash);
+      abbrToFull.set(c.hash.slice(0, 10), c.hash);
+    }
+
+    const branches: GitBranch[] = Object.entries(branchSummary.branches).map(
+      ([name, info]) => ({
+        name,
+        current: info.current,
+        remote: name.startsWith("remotes/"),
+        commitHash: abbrToFull.get(info.commit) ?? info.commit,
+        ahead: 0,
+        behind: 0,
+      }),
+    );
+
+    return { commits, branches };
+  }
+
+  async discardChanges(projectPath: string, files: string[]): Promise<void> {
+    const git = this.git(projectPath);
+    // Separate tracked vs untracked files
+    const s = await git.status();
+    const untrackedSet = new Set(s.not_added);
+    const tracked = files.filter((f) => !untrackedSet.has(f));
+    const untracked = files.filter((f) => untrackedSet.has(f));
+
+    if (tracked.length > 0) {
+      await git.checkout(["--", ...tracked]);
+    }
+    if (untracked.length > 0) {
+      await git.clean("f", ["-e", "!.*", "--", ...untracked]);
+    }
+  }
+
+  async cherryPick(projectPath: string, hash: string): Promise<void> {
+    await this.git(projectPath).raw(["cherry-pick", hash]);
+  }
+
+  async revert(projectPath: string, hash: string): Promise<void> {
+    await this.git(projectPath).raw(["revert", "--no-edit", hash]);
+  }
+
+  async createTag(
+    projectPath: string,
+    name: string,
+    hash?: string,
+  ): Promise<void> {
+    const args = ["tag", name];
+    if (hash) args.push(hash);
+    await this.git(projectPath).raw(args);
+  }
+
+  async getCreatePrUrl(
+    projectPath: string,
+    branch: string,
+  ): Promise<string | null> {
+    try {
+      const git = this.git(projectPath);
+      const remotes = await git.getRemotes(true);
+      const origin = remotes.find((r) => r.name === "origin");
+      if (!origin) return null;
+
+      const url = origin.refs.push || origin.refs.fetch;
+      if (!url) return null;
+
+      // Parse GitHub/GitLab URL
+      const parsed = this.parseRemoteUrl(url);
+      if (!parsed) return null;
+
+      const encodedBranch = encodeURIComponent(branch);
+      if (parsed.host.includes("github")) {
+        return `https://${parsed.host}/${parsed.owner}/${parsed.repo}/compare/${encodedBranch}?expand=1`;
+      }
+      if (parsed.host.includes("gitlab")) {
+        return `https://${parsed.host}/${parsed.owner}/${parsed.repo}/-/merge_requests/new?merge_request[source_branch]=${encodedBranch}`;
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  private parseRemoteUrl(
+    url: string,
+  ): { host: string; owner: string; repo: string } | null {
+    // SSH: git@github.com:owner/repo.git
+    const sshMatch = url.match(/^git@([^:]+):([^/]+)\/(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+      return {
+        host: sshMatch[1]!,
+        owner: sshMatch[2]!,
+        repo: sshMatch[3]!,
+      };
+    }
+    // HTTPS: https://github.com/owner/repo.git
+    try {
+      const parsed = new URL(url);
+      const parts = parsed.pathname.replace(/^\//, "").replace(/\.git$/, "").split("/");
+      if (parts.length >= 2) {
+        return {
+          host: parsed.host,
+          owner: parts[0]!,
+          repo: parts[1]!,
+        };
+      }
+    } catch {
+      // not a URL
+    }
+    return null;
+  }
+}
+
+export const gitService = new GitService();

package/src/services/project.service.ts

@@ -0,0 +1,107 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { resolve, basename, join } from "node:path";
+import { configService } from "./config.service.ts";
+import type { ProjectConfig } from "../types/config.ts";
+import type { ProjectInfo } from "../types/project.ts";
+
+const MAX_SCAN_DEPTH = 3;
+
+class ProjectService {
+  /** List all registered projects with optional git info */
+  list(): ProjectInfo[] {
+    const projects = configService.get("projects");
+    return projects.map((p) => ({
+      name: p.name,
+      path: p.path,
+    }));
+  }
+
+  /** Add a project by path. Auto-derives name from folder if not given. */
+  add(projectPath: string, name?: string): ProjectConfig {
+    const abs = resolve(projectPath);
+    if (!existsSync(abs)) {
+      throw new Error(`Path does not exist: ${abs}`);
+    }
+
+    const projects = configService.get("projects");
+    const projectName = name ?? basename(abs);
+
+    // Check duplicates
+    if (projects.some((p) => p.name === projectName)) {
+      throw new Error(`Project "${projectName}" already exists`);
+    }
+    if (projects.some((p) => resolve(p.path) === abs)) {
+      throw new Error(`Path "${abs}" already registered`);
+    }
+
+    const entry: ProjectConfig = { path: abs, name: projectName };
+    configService.set("projects", [...projects, entry]);
+    configService.save();
+    return entry;
+  }
+
+  /** Remove a project by name or path */
+  remove(nameOrPath: string): void {
+    const projects = configService.get("projects");
+    const abs = resolve(nameOrPath);
+    const filtered = projects.filter(
+      (p) => p.name !== nameOrPath && resolve(p.path) !== abs,
+    );
+
+    if (filtered.length === projects.length) {
+      throw new Error(`Project not found: ${nameOrPath}`);
+    }
+
+    configService.set("projects", filtered);
+    configService.save();
+  }
+
+  /** Resolve a project by name or path */
+  resolve(nameOrPath: string): ProjectConfig {
+    const projects = configService.get("projects");
+
+    // Try name first
+    const byName = projects.find((p) => p.name === nameOrPath);
+    if (byName) return byName;
+
+    // Try path
+    const abs = resolve(nameOrPath);
+    const byPath = projects.find((p) => resolve(p.path) === abs);
+    if (byPath) return byPath;
+
+    throw new Error(`Project not found: ${nameOrPath}`);
+  }
+
+  /** Scan a directory recursively for .git folders (up to MAX_SCAN_DEPTH) */
+  scanForGitRepos(dir: string, depth = 0): string[] {
+    const results: string[] = [];
+    const abs = resolve(dir);
+
+    if (depth > MAX_SCAN_DEPTH || !existsSync(abs)) return results;
+
+    try {
+      const entries = readdirSync(abs, { withFileTypes: true });
+
+      // Check if this directory itself is a git repo
+      if (entries.some((e) => e.name === ".git" && e.isDirectory())) {
+        results.push(abs);
+        return results; // Don't scan inside git repos
+      }
+
+      // Recurse into subdirectories
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".") || entry.name === "node_modules") {
+          continue;
+        }
+        results.push(...this.scanForGitRepos(join(abs, entry.name), depth + 1));
+      }
+    } catch {
+      // Permission denied or other FS error — skip
+    }
+
+    return results;
+  }
+}
+
+export const projectService = new ProjectService();

package/src/services/slash-items.service.ts

@@ -0,0 +1,184 @@
+import { resolve, basename, relative, sep } from "node:path";
+import { homedir } from "node:os";
+import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import yaml from "js-yaml";
+
+export interface SlashItem {
+  type: "skill" | "command";
+  /** Slash name, e.g. "review", "devops/deploy", "ck:research" */
+  name: string;
+  description: string;
+  argumentHint?: string;
+  /** Where the item comes from */
+  scope: "project" | "user";
+}
+
+/** Safely coerce a frontmatter value to string, returns undefined if not a scalar. */
+function str(val: unknown): string | undefined {
+  if (typeof val === "string") return val;
+  if (typeof val === "number" || typeof val === "boolean") return String(val);
+  return undefined;
+}
+
+/**
+ * Parse YAML frontmatter from a Markdown file.
+ */
+function parseFrontmatter(content: string): { meta: Record<string, unknown>; body: string } {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match || !match[1]) return { meta: {}, body: content };
+  try {
+    const meta = yaml.load(match[1]) as Record<string, unknown>;
+    const body = content.slice(match[0]!.length).trim();
+    return { meta: meta ?? {}, body };
+  } catch {
+    return { meta: {}, body: content };
+  }
+}
+
+/**
+ * Recursively walk a directory tree, calling `visitor` for every file.
+ * Ignores unreadable dirs/files silently.
+ */
+function walkDir(dir: string, visitor: (filePath: string) => void): void {
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = resolve(dir, entry);
+    try {
+      const stat = statSync(full);
+      if (stat.isDirectory()) {
+        walkDir(full, visitor);
+      } else if (stat.isFile()) {
+        visitor(full);
+      }
+    } catch { /* skip */ }
+  }
+}
+
+/**
+ * Collect commands from a commands directory (recursive).
+ * `commands/devops/deploy.md` → name `devops/deploy`
+ */
+function collectCommands(commandsDir: string, scope: "project" | "user"): SlashItem[] {
+  const items: SlashItem[] = [];
+  if (!existsSync(commandsDir)) return items;
+  walkDir(commandsDir, (filePath) => {
+    if (!filePath.endsWith(".md")) return;
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const { meta } = parseFrontmatter(content);
+      const rel = relative(commandsDir, filePath);
+      const name = rel.replace(/\.md$/, "").split(sep).join("/");
+      items.push({
+        type: "command",
+        name: str(meta.name) ?? name,
+        description: str(meta.description) ?? "",
+        argumentHint: str(meta["argument-hint"]),
+        scope,
+      });
+    } catch { /* skip */ }
+  });
+  return items;
+}
+
+/**
+ * Collect skills from a skills directory.
+ *
+ * @param skillsDir    Root skills directory to scan
+ * @param scope        "project" or "user"
+ * @param strictMode   When true, ONLY pick up SKILL.md files (used for user-global
+ *                     which can have many supporting .md files per skill).
+ *                     When false, also pick up loose .md files outside SKILL.md dirs
+ *                     (used for project-local where flat layout is common).
+ */
+function collectSkills(skillsDir: string, scope: "project" | "user", strictMode: boolean): SlashItem[] {
+  const items: SlashItem[] = [];
+  if (!existsSync(skillsDir)) return items;
+
+  const dirsWithSkillMd = new Set<string>();
+
+  // Pass 1: SKILL.md files (directory-based skills)
+  walkDir(skillsDir, (filePath) => {
+    if (basename(filePath) !== "SKILL.md") return;
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const { meta } = parseFrontmatter(content);
+      const skillDir = resolve(filePath, "..");
+      dirsWithSkillMd.add(skillDir);
+      const rel = relative(skillsDir, skillDir);
+      const pathName = rel.split(sep).join("/");
+      const name = str(meta.name) ?? pathName;
+      if (!name) return;
+      items.push({
+        type: "skill",
+        name,
+        description: str(meta.description) ?? "",
+        scope,
+      });
+    } catch { /* skip */ }
+  });
+
+  // Pass 2 (only in relaxed mode): loose .md files not inside a SKILL.md directory
+  if (!strictMode) {
+    walkDir(skillsDir, (filePath) => {
+      if (!filePath.endsWith(".md")) return;
+      if (basename(filePath) === "SKILL.md") return;
+      const dir = resolve(filePath, "..");
+      // Skip supporting files inside a skill dir (or any ancestor)
+      let ancestor = dir;
+      while (ancestor.startsWith(skillsDir) && ancestor !== skillsDir) {
+        if (dirsWithSkillMd.has(ancestor)) return;
+        ancestor = resolve(ancestor, "..");
+      }
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        const { meta } = parseFrontmatter(content);
+        const rel = relative(skillsDir, filePath);
+        const pathName = rel.replace(/\.md$/, "").split(sep).join("/");
+        const name = str(meta.name) ?? pathName;
+        if (!name) return;
+        items.push({
+          type: "skill",
+          name,
+          description: str(meta.description) ?? "",
+          scope,
+        });
+      } catch { /* skip */ }
+    });
+  }
+
+  return items;
+}
+
+/**
+ * Scan for available slash commands and skills.
+ *
+ * Sources (merged, project overrides user if same name):
+ *   1. User-global:   ~/.claude/commands/  and  ~/.claude/skills/   (strict: SKILL.md only)
+ *   2. Project-local:  <projectPath>/.claude/commands/  and  .claude/skills/  (relaxed: also loose .md)
+ */
+export function listSlashItems(projectPath: string): SlashItem[] {
+  const home = homedir();
+  const globalClaude = resolve(home, ".claude");
+
+  // Collect from both scopes (user-global uses strict mode)
+  const userCommands = collectCommands(resolve(globalClaude, "commands"), "user");
+  const userSkills = collectSkills(resolve(globalClaude, "skills"), "user", true);
+  const projectCommands = collectCommands(resolve(projectPath, ".claude", "commands"), "project");
+  const projectSkills = collectSkills(resolve(projectPath, ".claude", "skills"), "project", false);
+
+  // Merge: project items override user items with the same name
+  const map = new Map<string, SlashItem>();
+  for (const item of [...userCommands, ...userSkills]) {
+    map.set(`${item.type}:${item.name}`, item);
+  }
+  for (const item of [...projectCommands, ...projectSkills]) {
+    map.set(`${item.type}:${item.name}`, item);
+  }
+
+  return Array.from(map.values());
+}