@hienlh/ppm 0.1.0

package/src/cli/commands/git-cmd.ts

@@ -0,0 +1,315 @@
+import { Command } from "commander";
+import type { GitStatus } from "../../types/git.ts";
+
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  dim: "\x1b[2m",
+  magenta: "\x1b[35m",
+};
+
+function statusColor(s: string): string {
+  if (s === "M") return `${C.yellow}M${C.reset}`;
+  if (s === "A") return `${C.green}A${C.reset}`;
+  if (s === "D") return `${C.red}D${C.reset}`;
+  if (s === "R") return `${C.cyan}R${C.reset}`;
+  return s;
+}
+
+function printStatus(status: GitStatus): void {
+  console.log(`${C.bold}On branch:${C.reset} ${C.cyan}${status.current ?? "(detached)"}${C.reset}`);
+
+  if (status.staged.length === 0 && status.unstaged.length === 0 && status.untracked.length === 0) {
+    console.log(`${C.green}Nothing to commit, working tree clean${C.reset}`);
+    return;
+  }
+
+  if (status.staged.length > 0) {
+    console.log(`\n${C.bold}Staged changes:${C.reset}`);
+    for (const f of status.staged) {
+      const label = f.oldPath ? `${f.oldPath} → ${f.path}` : f.path;
+      console.log(`  ${statusColor(f.status)}  ${label}`);
+    }
+  }
+
+  if (status.unstaged.length > 0) {
+    console.log(`\n${C.bold}Unstaged changes:${C.reset}`);
+    for (const f of status.unstaged) {
+      console.log(`  ${statusColor(f.status)}  ${f.path}`);
+    }
+  }
+
+  if (status.untracked.length > 0) {
+    console.log(`\n${C.bold}Untracked files:${C.reset}`);
+    for (const f of status.untracked) {
+      console.log(`  ${C.dim}?  ${f}${C.reset}`);
+    }
+  }
+}
+
+export function registerGitCommands(program: Command): void {
+  const git = program.command("git").description("Git operations for a project");
+
+  git
+    .command("status")
+    .description("Show working tree status")
+    .option("-p, --project <name>", "Project name or path")
+    .action(async (options: { project?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        const status = await gitService.status(project.path);
+        printStatus(status);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  git
+    .command("log")
+    .description("Show recent commits")
+    .option("-p, --project <name>", "Project name or path")
+    .option("-n, --count <n>", "Number of commits to show", "20")
+    .action(async (options: { project?: string; count?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        const maxCount = Math.min(parseInt(options.count ?? "20", 10), 500);
+        const { commits } = await gitService.graphData(project.path, maxCount);
+
+        if (commits.length === 0) {
+          console.log(`${C.yellow}No commits found.${C.reset}`);
+          return;
+        }
+
+        for (const c of commits) {
+          const hash = `${C.yellow}${c.abbreviatedHash}${C.reset}`;
+          const subject = c.subject;
+          const author = `${C.cyan}${c.authorName}${C.reset}`;
+          const date = `${C.dim}${new Date(c.authorDate).toLocaleDateString()}${C.reset}`;
+          const refs = c.refs.length > 0
+            ? ` ${C.green}(${c.refs.join(", ")})${C.reset}`
+            : "";
+          console.log(`${hash}${refs} ${subject}`);
+          console.log(`       ${author} · ${date}`);
+        }
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  git
+    .command("diff")
+    .description("Show diff between refs or working tree")
+    .option("-p, --project <name>", "Project name or path")
+    .argument("[ref1]", "First ref")
+    .argument("[ref2]", "Second ref")
+    .action(async (ref1: string | undefined, ref2: string | undefined, options: { project?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        const diff = await gitService.diff(project.path, ref1, ref2);
+        if (!diff.trim()) {
+          console.log(`${C.dim}No differences.${C.reset}`);
+        } else {
+          // Color diff output
+          for (const line of diff.split("\n")) {
+            if (line.startsWith("+") && !line.startsWith("+++")) {
+              process.stdout.write(`${C.green}${line}${C.reset}\n`);
+            } else if (line.startsWith("-") && !line.startsWith("---")) {
+              process.stdout.write(`${C.red}${line}${C.reset}\n`);
+            } else if (line.startsWith("@@")) {
+              process.stdout.write(`${C.cyan}${line}${C.reset}\n`);
+            } else {
+              process.stdout.write(`${line}\n`);
+            }
+          }
+        }
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  git
+    .command("stage <files...>")
+    .description('Stage files (use "." to stage all)')
+    .option("-p, --project <name>", "Project name or path")
+    .action(async (files: string[], options: { project?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        await gitService.stage(project.path, files);
+        console.log(`${C.green}Staged:${C.reset} ${files.join(", ")}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  git
+    .command("unstage <files...>")
+    .description("Unstage files")
+    .option("-p, --project <name>", "Project name or path")
+    .action(async (files: string[], options: { project?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        await gitService.unstage(project.path, files);
+        console.log(`${C.yellow}Unstaged:${C.reset} ${files.join(", ")}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  git
+    .command("commit")
+    .description("Commit staged changes")
+    .option("-p, --project <name>", "Project name or path")
+    .requiredOption("-m, --message <msg>", "Commit message")
+    .action(async (options: { project?: string; message: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+
+        // Check if there's anything to commit
+        const status = await gitService.status(project.path);
+        if (status.staged.length === 0) {
+          console.error(`${C.red}Nothing to commit.${C.reset} Stage files first with: ppm git stage <files>`);
+          process.exit(1);
+        }
+
+        const hash = await gitService.commit(project.path, options.message);
+        console.log(`${C.green}Committed:${C.reset} ${C.yellow}${hash}${C.reset} "${options.message}"`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  git
+    .command("push")
+    .description("Push to remote")
+    .option("-p, --project <name>", "Project name or path")
+    .option("--remote <remote>", "Remote name", "origin")
+    .option("--branch <branch>", "Branch name")
+    .action(async (options: { project?: string; remote?: string; branch?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        console.log(`${C.dim}Pushing...${C.reset}`);
+        await gitService.push(project.path, options.remote, options.branch);
+        console.log(`${C.green}Pushed successfully.${C.reset}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  git
+    .command("pull")
+    .description("Pull from remote")
+    .option("-p, --project <name>", "Project name or path")
+    .option("--remote <remote>", "Remote name")
+    .option("--branch <branch>", "Branch name")
+    .action(async (options: { project?: string; remote?: string; branch?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        console.log(`${C.dim}Pulling...${C.reset}`);
+        await gitService.pull(project.path, options.remote, options.branch);
+        console.log(`${C.green}Pulled successfully.${C.reset}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  // ppm git branch <subcommand>
+  const branch = git.command("branch").description("Branch operations");
+
+  branch
+    .command("create <name>")
+    .description("Create and checkout a new branch")
+    .option("-p, --project <name>", "Project name or path")
+    .option("--from <ref>", "Base ref (commit/branch/tag)")
+    .action(async (name: string, options: { project?: string; from?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        await gitService.createBranch(project.path, name, options.from);
+        console.log(`${C.green}Created and checked out branch:${C.reset} ${C.cyan}${name}${C.reset}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  branch
+    .command("checkout <name>")
+    .description("Switch to a branch")
+    .option("-p, --project <name>", "Project name or path")
+    .action(async (name: string, options: { project?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        await gitService.checkout(project.path, name);
+        console.log(`${C.green}Switched to branch:${C.reset} ${C.cyan}${name}${C.reset}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  branch
+    .command("delete <name>")
+    .description("Delete a branch")
+    .option("-p, --project <name>", "Project name or path")
+    .option("-f, --force", "Force delete")
+    .action(async (name: string, options: { project?: string; force?: boolean }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        await gitService.deleteBranch(project.path, name, options.force);
+        console.log(`${C.green}Deleted branch:${C.reset} ${C.cyan}${name}${C.reset}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  branch
+    .command("merge <source>")
+    .description("Merge a branch into current branch")
+    .option("-p, --project <name>", "Project name or path")
+    .action(async (source: string, options: { project?: string }) => {
+      try {
+        const { resolveProject } = await import("../utils/project-resolver.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const project = resolveProject(options);
+        await gitService.merge(project.path, source);
+        console.log(`${C.green}Merged:${C.reset} ${C.cyan}${source}${C.reset} into current branch`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,57 @@
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { configService } from "../../services/config.service.ts";
+import { projectService } from "../../services/project.service.ts";
+
+export async function initProject() {
+  const ppmDir = resolve(homedir(), ".ppm");
+  const globalConfig = resolve(ppmDir, "config.yaml");
+
+  // Load existing or create default
+  configService.load();
+  console.log(`Config: ${configService.getConfigPath()}`);
+
+  // Scan CWD for git repos
+  const cwd = process.cwd();
+  console.log(`\nScanning ${cwd} for git repositories...`);
+  const repos = projectService.scanForGitRepos(cwd);
+
+  if (repos.length === 0) {
+    console.log("No git repositories found.");
+  } else {
+    console.log(`Found ${repos.length} git repo(s):\n`);
+    const existing = configService.get("projects");
+
+    let added = 0;
+    for (const repoPath of repos) {
+      const name = repoPath.split("/").pop() ?? "unknown";
+      const alreadyRegistered = existing.some(
+        (p) => resolve(p.path) === repoPath || p.name === name,
+      );
+
+      if (alreadyRegistered) {
+        console.log(`  [skip] ${name} (${repoPath}) — already registered`);
+        continue;
+      }
+
+      try {
+        projectService.add(repoPath, name);
+        console.log(`  [added] ${name} (${repoPath})`);
+        added++;
+      } catch (e) {
+        console.log(`  [error] ${name}: ${(e as Error).message}`);
+      }
+    }
+
+    console.log(`\nAdded ${added} project(s).`);
+  }
+
+  const auth = configService.get("auth");
+  console.log(`\nAuth: ${auth.enabled ? "enabled" : "disabled"}`);
+  if (auth.enabled) {
+    console.log(`Token: ${auth.token}`);
+  }
+
+  console.log(`\nRun "ppm start" to start the server.`);
+}

package/src/cli/commands/open.ts

@@ -0,0 +1,19 @@
+import { configService } from "../../services/config.service.ts";
+
+export async function openBrowser() {
+  configService.load();
+  const port = configService.get("port");
+  const url = `http://localhost:${port}`;
+
+  console.log(`Opening ${url} ...`);
+
+  const platform = process.platform;
+  const cmd =
+    platform === "darwin"
+      ? ["open", url]
+      : platform === "win32"
+        ? ["cmd", "/c", "start", url]
+        : ["xdg-open", url];
+
+  Bun.spawn({ cmd, stdio: ["ignore", "ignore", "ignore"] });
+}

package/src/cli/commands/projects.ts

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  dim: "\x1b[2m",
+};
+
+function printTable(headers: string[], rows: string[][]): void {
+  const colWidths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)),
+  );
+
+  const sep = colWidths.map((w) => "-".repeat(w + 2)).join("+");
+  const headerLine = headers
+    .map((h, i) => ` ${h.padEnd(colWidths[i]!)} `)
+    .join("|");
+
+  console.log(`+${sep}+`);
+  console.log(`|${C.bold}${headerLine}${C.reset}|`);
+  console.log(`+${sep}+`);
+  for (const row of rows) {
+    const line = row.map((cell, i) => ` ${(cell ?? "").padEnd(colWidths[i]!)} `).join("|");
+    console.log(`|${line}|`);
+  }
+  console.log(`+${sep}+`);
+}
+
+export function registerProjectsCommands(program: Command): void {
+  const projects = program.command("projects").description("Manage registered projects");
+
+  projects
+    .command("list")
+    .description("List all registered projects")
+    .action(async () => {
+      try {
+        const { projectService } = await import("../../services/project.service.ts");
+        const { gitService } = await import("../../services/git.service.ts");
+        const list = projectService.list();
+
+        if (list.length === 0) {
+          console.log(`${C.yellow}No projects registered.${C.reset} Run: ppm init`);
+          return;
+        }
+
+        const rows: string[][] = [];
+        for (const p of list) {
+          let branch = "-";
+          let status = "-";
+          try {
+            const s = await gitService.status(p.path);
+            branch = s.current ?? "-";
+            const dirty = s.staged.length + s.unstaged.length + s.untracked.length;
+            status = dirty > 0 ? `${C.yellow}dirty${C.reset}` : `${C.green}clean${C.reset}`;
+          } catch {
+            status = `${C.dim}no git${C.reset}`;
+          }
+          rows.push([p.name, p.path, branch, status]);
+        }
+
+        printTable(["Name", "Path", "Branch", "Status"], rows);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  projects
+    .command("add <path>")
+    .description("Add a project to the registry")
+    .option("-n, --name <name>", "Project name (defaults to folder name)")
+    .action(async (projectPath: string, options: { name?: string }) => {
+      try {
+        const { projectService } = await import("../../services/project.service.ts");
+        const entry = projectService.add(projectPath, options.name);
+        console.log(`${C.green}Added project:${C.reset} ${entry.name} → ${entry.path}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+
+  projects
+    .command("remove <name>")
+    .description("Remove a project from the registry")
+    .action(async (nameOrPath: string) => {
+      try {
+        const { projectService } = await import("../../services/project.service.ts");
+        projectService.remove(nameOrPath);
+        console.log(`${C.green}Removed project:${C.reset} ${nameOrPath}`);
+      } catch (err) {
+        console.error(`${C.red}Error:${C.reset}`, (err as Error).message);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/start.ts

@@ -0,0 +1,3 @@
+import { startServer } from "../../server/index.ts";
+
+export { startServer };

package/src/cli/commands/stop.ts

@@ -0,0 +1,33 @@
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { readFileSync, unlinkSync, existsSync } from "node:fs";
+
+const PID_FILE = resolve(homedir(), ".ppm", "ppm.pid");
+
+export async function stopServer() {
+  if (!existsSync(PID_FILE)) {
+    console.log("No PPM daemon running (PID file not found).");
+    return;
+  }
+
+  const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (isNaN(pid)) {
+    console.log("Invalid PID file. Removing it.");
+    unlinkSync(PID_FILE);
+    return;
+  }
+
+  try {
+    process.kill(pid);
+    unlinkSync(PID_FILE);
+    console.log(`PPM daemon stopped (PID: ${pid}).`);
+  } catch (e) {
+    const error = e as NodeJS.ErrnoException;
+    if (error.code === "ESRCH") {
+      console.log(`Process ${pid} not found. Cleaning up PID file.`);
+      unlinkSync(PID_FILE);
+    } else {
+      console.error(`Failed to stop process ${pid}: ${error.message}`);
+    }
+  }
+}

package/src/cli/utils/project-resolver.ts

@@ -0,0 +1,27 @@
+import { resolve } from "node:path";
+import { projectService } from "../../services/project.service.ts";
+import type { ProjectConfig } from "../../types/config.ts";
+
+/**
+ * CLI project resolver: CWD auto-detect + `-p` flag override.
+ * Used by CLI commands that operate on a specific project.
+ */
+export function resolveProject(options: { project?: string }): ProjectConfig {
+  // Explicit -p flag
+  if (options.project) {
+    return projectService.resolve(options.project);
+  }
+
+  // Auto-detect from CWD
+  const cwd = process.cwd();
+  const projects = projectService.list();
+  const match = projects.find(
+    (p) => cwd === resolve(p.path) || cwd.startsWith(resolve(p.path) + "/"),
+  );
+
+  if (match) return { name: match.name, path: match.path };
+
+  throw new Error(
+    "Not in a registered project directory. Use -p <name> or register with: ppm init",
+  );
+}

package/src/index.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+
+const program = new Command();
+
+program
+  .name("ppm")
+  .description("Personal Project Manager — mobile-first web IDE")
+  .version("0.1.0");
+
+program
+  .command("start")
+  .description("Start the PPM server")
+  .option("-p, --port <port>", "Port to listen on")
+  .option("-d, --daemon", "Run as background daemon")
+  .option("-c, --config <path>", "Path to config file")
+  .action(async (options) => {
+    const { startServer } = await import("./server/index.ts");
+    await startServer(options);
+  });
+
+program
+  .command("stop")
+  .description("Stop the PPM daemon")
+  .action(async () => {
+    const { stopServer } = await import("./cli/commands/stop.ts");
+    await stopServer();
+  });
+
+program
+  .command("open")
+  .description("Open PPM in browser")
+  .option("-c, --config <path>", "Path to config file")
+  .action(async () => {
+    const { openBrowser } = await import("./cli/commands/open.ts");
+    await openBrowser();
+  });
+
+program
+  .command("init")
+  .description("Initialize PPM configuration — scan for git repos, create config")
+  .action(async () => {
+    const { initProject } = await import("./cli/commands/init.ts");
+    await initProject();
+  });
+
+const { registerProjectsCommands } = await import("./cli/commands/projects.ts");
+registerProjectsCommands(program);
+
+const { registerConfigCommands } = await import("./cli/commands/config-cmd.ts");
+registerConfigCommands(program);
+
+const { registerGitCommands } = await import("./cli/commands/git-cmd.ts");
+registerGitCommands(program);
+
+const { registerChatCommands } = await import("./cli/commands/chat-cmd.ts");
+registerChatCommands(program);
+
+program.parse();