mindcontext-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1443 @@
+#!/usr/bin/env node
+
+
+// src/commands/init.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { createInterface } from "readline";
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/lib/machine-id.ts
+import { createHash } from "crypto";
+import { hostname, userInfo } from "os";
+import { execSync } from "child_process";
+function getMachineId() {
+  const host = hostname();
+  const user = userInfo().username;
+  let gitEmail = "";
+  try {
+    gitEmail = execSync("git config user.email", { encoding: "utf8" }).trim();
+  } catch {
+  }
+  const hash = createHash("sha256").update(`${host}-${user}-${gitEmail}`).digest("hex").substring(0, 8);
+  const name = `${user}-${host}`.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  return { name, id: hash };
+}
+function getTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toISOString().replace(/:/g, "-").replace(/\.\d{3}Z$/, "");
+}
+function generateUpdateFilename() {
+  const { name, id } = getMachineId();
+  const timestamp = getTimestamp();
+  return `${timestamp}_${name}_${id}.json`;
+}
+
+// src/lib/config.ts
+var MINDCONTEXT_DIR = join(homedir(), ".mindcontext");
+var CONFIG_FILE = join(MINDCONTEXT_DIR, "config.json");
+var REPO_DIR = join(MINDCONTEXT_DIR, "repo");
+var PENDING_FILE = join(MINDCONTEXT_DIR, "pending.json");
+function getMindcontextDir() {
+  return MINDCONTEXT_DIR;
+}
+function getRepoDir() {
+  return REPO_DIR;
+}
+function isInitialized() {
+  return existsSync(CONFIG_FILE) && existsSync(REPO_DIR);
+}
+function createDefaultConfig() {
+  const machine = getMachineId();
+  return {
+    version: "1.0",
+    dashboard_repo: "",
+    dashboard_url: "",
+    projects: {},
+    machine
+  };
+}
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(CONFIG_FILE, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config2) {
+  if (!existsSync(MINDCONTEXT_DIR)) {
+    mkdirSync(MINDCONTEXT_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
+}
+function readPending() {
+  if (!existsSync(PENDING_FILE)) {
+    return [];
+  }
+  try {
+    const content = readFileSync(PENDING_FILE, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function writePending(pending) {
+  writeFileSync(PENDING_FILE, JSON.stringify(pending, null, 2));
+}
+function addPending(message) {
+  const pending = readPending();
+  pending.push({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    message
+  });
+  writePending(pending);
+}
+function clearPending() {
+  if (existsSync(PENDING_FILE)) {
+    writeFileSync(PENDING_FILE, "[]");
+  }
+}
+function getProjectDir(projectName) {
+  return join(REPO_DIR, "projects", projectName, "updates");
+}
+function ensureProjectDir(projectName) {
+  const dir = getProjectDir(projectName);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/lib/git-ops.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+var execOptions = {
+  encoding: "utf8",
+  stdio: ["pipe", "pipe", "pipe"]
+};
+function cloneRepo(repoUrl, targetDir) {
+  execSync2(`git clone "${repoUrl}" "${targetDir}"`, execOptions);
+}
+function pull() {
+  const repoDir = getRepoDir();
+  if (!existsSync2(repoDir)) {
+    return { success: false, message: "Repository not initialized" };
+  }
+  try {
+    const output = execSync2("git pull --rebase origin main", {
+      ...execOptions,
+      cwd: repoDir
+    });
+    return { success: true, message: output.trim() };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Pull failed";
+    return { success: false, message };
+  }
+}
+function stageAll() {
+  const repoDir = getRepoDir();
+  execSync2("git add -A", { ...execOptions, cwd: repoDir });
+}
+function commit(message) {
+  const repoDir = getRepoDir();
+  try {
+    const status = execSync2("git status --porcelain", {
+      ...execOptions,
+      cwd: repoDir
+    });
+    if (!status.trim()) {
+      return { success: true, message: "Nothing to commit" };
+    }
+    stageAll();
+    execSync2(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+      ...execOptions,
+      cwd: repoDir
+    });
+    return { success: true, message: "Committed" };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : "Commit failed";
+    return { success: false, message: msg };
+  }
+}
+function push() {
+  const repoDir = getRepoDir();
+  try {
+    execSync2("git push origin main", {
+      ...execOptions,
+      cwd: repoDir,
+      timeout: 3e4
+    });
+    return { success: true, message: "Pushed to remote" };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Push failed";
+    return { success: false, message };
+  }
+}
+function sync(commitMessage) {
+  const pending = readPending();
+  if (pending.length > 0) {
+    const pushResult2 = push();
+    if (pushResult2.success) {
+      clearPending();
+    }
+  }
+  const commitResult = commit(commitMessage);
+  if (!commitResult.success) {
+    return {
+      committed: false,
+      pushed: false,
+      message: commitResult.message
+    };
+  }
+  if (commitResult.message === "Nothing to commit") {
+    return {
+      committed: false,
+      pushed: false,
+      message: "No changes to sync"
+    };
+  }
+  const pushResult = push();
+  if (!pushResult.success) {
+    addPending(commitMessage);
+    return {
+      committed: true,
+      pushed: false,
+      message: "Committed locally. Push pending (offline)"
+    };
+  }
+  return {
+    committed: true,
+    pushed: true,
+    message: "Synced successfully"
+  };
+}
+function getRecentCommits(projectPath, limit = 5) {
+  try {
+    const output = execSync2(
+      `git log --oneline -${limit} --format="%s"`,
+      { ...execOptions, cwd: projectPath }
+    );
+    return output.trim().split("\n").filter((line) => line.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/init.ts
+async function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve5) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve5(answer.trim());
+    });
+  });
+}
+async function init(options = {}) {
+  const mindcontextDir = getMindcontextDir();
+  const repoDir = getRepoDir();
+  if (isInitialized()) {
+    const config3 = readConfig();
+    if (!options.quiet) {
+      console.log("MindContext is already initialized.");
+      console.log(`  Directory: ${mindcontextDir}`);
+      console.log(`  Dashboard: ${config3?.dashboard_url || "Not configured"}`);
+      console.log(`  Projects: ${Object.keys(config3?.projects || {}).length}`);
+      console.log("");
+      console.log('Run "mc reset" to start fresh.');
+    }
+    return;
+  }
+  if (!options.quiet) {
+    console.log("Initializing MindContext...\n");
+  }
+  if (!existsSync3(mindcontextDir)) {
+    mkdirSync2(mindcontextDir, { recursive: true });
+  }
+  let dashboardRepo = "";
+  if (!options.quiet) {
+    console.log("Enter your dashboard repository URL.");
+    console.log("(Create one from https://github.com/tmsjngx0/mindcontext-template)\n");
+    dashboardRepo = await prompt("Dashboard repo URL (git@github.com:user/repo.git): ");
+  }
+  if (!dashboardRepo) {
+    if (!options.quiet) {
+      console.log("\nNo dashboard URL provided. You can configure it later with:");
+      console.log("  mc config --dashboard-repo <url>");
+    }
+    const config3 = createDefaultConfig();
+    writeConfig(config3);
+    if (!options.quiet) {
+      console.log(`
+Created: ${mindcontextDir}/config.json`);
+    }
+    return;
+  }
+  if (!options.quiet) {
+    console.log(`
+Cloning dashboard repository...`);
+  }
+  try {
+    cloneRepo(dashboardRepo, repoDir);
+  } catch (error) {
+    console.error("Failed to clone repository:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+  let dashboardUrl = "";
+  const match = dashboardRepo.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+  if (match) {
+    dashboardUrl = `https://${match[1]}.github.io/${match[2]}`;
+  }
+  const config2 = createDefaultConfig();
+  config2.dashboard_repo = dashboardRepo;
+  config2.dashboard_url = dashboardUrl;
+  writeConfig(config2);
+  if (!options.quiet) {
+    console.log("\n\u2713 MindContext initialized!");
+    console.log(`  Directory: ${mindcontextDir}`);
+    console.log(`  Dashboard: ${dashboardUrl}`);
+    console.log("");
+    console.log("Next steps:");
+    console.log("  cd <your-project>");
+    console.log("  mc connect");
+  }
+}
+
+// src/commands/connect.ts
+import { basename as basename2, resolve, join as join3 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+
+// src/parsers/openspec.ts
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2, basename } from "path";
+function hasOpenSpec(projectPath) {
+  const openspecDir = join2(projectPath, "openspec");
+  return existsSync4(openspecDir) && existsSync4(join2(openspecDir, "changes"));
+}
+function parseTasksFile(filepath) {
+  if (!existsSync4(filepath)) {
+    return { total: 0, complete: 0 };
+  }
+  const content = readFileSync2(filepath, "utf8");
+  const lines = content.split("\n");
+  let total = 0;
+  let complete = 0;
+  for (const line of lines) {
+    if (/^\s*-\s*\[\s*\]\s/.test(line)) {
+      total++;
+    } else if (/^\s*-\s*\[x\]\s/i.test(line)) {
+      total++;
+      complete++;
+    }
+  }
+  return { total, complete };
+}
+function determineStatus(tasksTotal, tasksComplete) {
+  if (tasksTotal === 0) {
+    return "proposed";
+  }
+  if (tasksComplete === 0) {
+    return "proposed";
+  }
+  if (tasksComplete === tasksTotal) {
+    return "done";
+  }
+  return "in_progress";
+}
+function parseChange(changePath) {
+  const id = basename(changePath);
+  if (id === "archive") {
+    return null;
+  }
+  const tasksFile = join2(changePath, "tasks.md");
+  const { total, complete } = parseTasksFile(tasksFile);
+  return {
+    id,
+    tasksTotal: total,
+    tasksComplete: complete,
+    status: determineStatus(total, complete)
+  };
+}
+function parseOpenSpec(projectPath) {
+  if (!hasOpenSpec(projectPath)) {
+    return { found: false, changes: [], activeChange: null };
+  }
+  const changesDir = join2(projectPath, "openspec", "changes");
+  const entries = readdirSync(changesDir, { withFileTypes: true });
+  const changes = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const change = parseChange(join2(changesDir, entry.name));
+      if (change) {
+        changes.push(change);
+      }
+    }
+  }
+  let activeChange = null;
+  for (const change of changes) {
+    if (change.status === "in_progress") {
+      activeChange = change;
+      break;
+    }
+  }
+  if (!activeChange) {
+    for (const change of changes) {
+      if (change.status === "review") {
+        activeChange = change;
+        break;
+      }
+    }
+  }
+  if (!activeChange) {
+    for (const change of changes) {
+      if (change.status === "proposed" && change.tasksTotal > 0) {
+        activeChange = change;
+        break;
+      }
+    }
+  }
+  return { found: true, changes, activeChange };
+}
+function getOpenSpecProgress(projectPath) {
+  const result = parseOpenSpec(projectPath);
+  if (!result.found || !result.activeChange) {
+    return {
+      source: "manual",
+      tasks_done: 0,
+      tasks_total: 0
+    };
+  }
+  return {
+    source: "openspec",
+    change: result.activeChange.id,
+    tasks_done: result.activeChange.tasksComplete,
+    tasks_total: result.activeChange.tasksTotal
+  };
+}
+
+// src/lib/templates.ts
+var COMMAND_TEMPLATES = {
+  "prime.md": `---
+description: Load context and show what to work on
+---
+
+# Prime Context
+
+Load project context at the start of your session.
+
+## Step 1: Get Current Context
+
+\`\`\`bash
+mc context --json
+\`\`\`
+
+## Step 2: Load Last Session Notes
+
+From the context output, identify:
+- **Last session summary** - What was accomplished
+- **Next tasks** - What was planned for this session
+- **Current change** - The OpenSpec change being worked on
+- **Progress** - Tasks completed vs total
+
+## Step 3: Show Context Summary
+
+Display to the user:
+
+\`\`\`
+SESSION CONTEXT LOADED
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+Project: [project name]
+Change: [current openspec change]
+Progress: [tasks_done]/[tasks_total] ([percentage]%)
+
+Last Session:
+- [notes from last update]
+
+Planned for This Session:
+- [next tasks from last update]
+\`\`\`
+
+## Step 4: Suggest Next Action
+
+Based on context, suggest what to work on next.
+`,
+  "update.md": `---
+description: Save session context and sync progress
+---
+
+# Update Context
+
+Save your session progress with auto-generated context.
+
+## Step 1: Generate Session Summary
+
+From your conversation context, summarize what was accomplished:
+- Recent code changes and commits
+- Tasks completed
+- Features implemented or bugs fixed
+
+Create 3-5 concise bullet points.
+
+## Step 2: Generate Next Tasks
+
+From OpenSpec and conversation context, identify what should be done next:
+- Remaining tasks from current OpenSpec change
+- Blockers or pending items mentioned
+
+Create 2-4 actionable next task items.
+
+## Step 3: Run mc sync
+
+\`\`\`bash
+mc sync --notes "First accomplishment
+Second accomplishment" --next "Next task 1
+Next task 2"
+\`\`\`
+
+Use multiline strings - each line becomes one item.
+
+## Step 4: Show Confirmation
+
+\`\`\`
+PROGRESS SYNCED
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+Session Summary:
+- [generated notes]
+
+Next Session:
+- [generated next tasks]
+\`\`\`
+`,
+  "progress.md": `---
+description: Show progress
+---
+
+Run \`mc progress\` to see current progress in the terminal.
+
+Options:
+- \`--web\` - Open the web dashboard in your browser
+
+This aggregates all update files to show:
+- Current change and task completion
+- Recent activity across machines
+- Team member status (if collaborative)
+`,
+  "context.md": `---
+description: Output current context
+---
+
+Run \`mc context\` to output the current project context.
+
+Options:
+- \`--json\` - Output as JSON (for integration with other tools)
+
+This shows:
+- Project connection status
+- Current OpenSpec change and progress
+- Last update details
+- Team activity summary
+`
+};
+var HOOK_TEMPLATES = {
+  "session-end.js": `const { execSync } = require('child_process');
+
+module.exports = async function() {
+  try {
+    execSync('mc sync --quiet', {
+      stdio: 'inherit',
+      timeout: 10000
+    });
+  } catch (e) {
+    // Sync failed silently - don't block session end
+  }
+};
+`
+};
+
+// src/commands/connect.ts
+async function connect(options = {}) {
+  if (!isInitialized()) {
+    console.error('MindContext is not initialized. Run "mc init" first.');
+    process.exit(1);
+  }
+  const config2 = readConfig();
+  if (!config2) {
+    console.error("Failed to read config.");
+    process.exit(1);
+  }
+  const projectPath = resolve(process.cwd());
+  const projectName = options.name || basename2(projectPath);
+  if (config2.projects[projectName]) {
+    if (!options.quiet) {
+      console.log(`Project "${projectName}" is already connected.`);
+      console.log(`  Path: ${config2.projects[projectName].path}`);
+      console.log(`  Category: ${config2.projects[projectName].category}`);
+      console.log(`  OpenSpec: ${config2.projects[projectName].openspec ? "Yes" : "No"}`);
+    }
+    return;
+  }
+  const openspec = hasOpenSpec(projectPath);
+  config2.projects[projectName] = {
+    path: projectPath,
+    openspec,
+    category: options.category || "default"
+  };
+  writeConfig(config2);
+  ensureProjectDir(projectName);
+  const claudeDir = join3(projectPath, ".claude");
+  const commandsDir = join3(claudeDir, "commands", "mc");
+  if (!existsSync5(commandsDir)) {
+    mkdirSync3(commandsDir, { recursive: true });
+    for (const [filename, content] of Object.entries(COMMAND_TEMPLATES)) {
+      writeFileSync2(join3(commandsDir, filename), content);
+    }
+    if (!options.quiet) {
+      console.log(`\u2713 Created .claude/commands/mc/`);
+    }
+  }
+  if (options.withHooks) {
+    const hooksDir = join3(claudeDir, "hooks");
+    if (!existsSync5(hooksDir)) {
+      mkdirSync3(hooksDir, { recursive: true });
+      for (const [filename, content] of Object.entries(HOOK_TEMPLATES)) {
+        writeFileSync2(join3(hooksDir, filename), content);
+      }
+      if (!options.quiet) {
+        console.log(`\u2713 Created .claude/hooks/`);
+      }
+    }
+  }
+  if (!options.quiet) {
+    console.log(`\u2713 Connected "${projectName}"`);
+    console.log(`  Path: ${projectPath}`);
+    console.log(`  Category: ${options.category || "default"}`);
+    console.log(`  OpenSpec: ${openspec ? "Detected" : "Not found"}`);
+    console.log("");
+    console.log('Next: Run "mc sync" to create your first update.');
+  }
+}
+
+// src/commands/sync.ts
+import { basename as basename3, resolve as resolve2 } from "path";
+
+// src/lib/update-file.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+function createUpdateFile(projectName, progress2, context2, recentCommits) {
+  const { name, id } = getMachineId();
+  const filename = generateUpdateFilename();
+  const filepath = join4(getProjectDir(projectName), filename);
+  const update = {
+    version: "1.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    machine: name,
+    machine_id: id,
+    project: projectName,
+    progress: progress2,
+    context: context2,
+    recent_commits: recentCommits
+  };
+  ensureProjectDir(projectName);
+  writeFileSync3(filepath, JSON.stringify(update, null, 2));
+  return filepath;
+}
+function readUpdateFiles(projectName) {
+  const dir = getProjectDir(projectName);
+  if (!existsSync6(dir)) {
+    return [];
+  }
+  const files = readdirSync2(dir).filter((f) => f.endsWith(".json"));
+  const updates = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync3(join4(dir, file), "utf8");
+      updates.push(JSON.parse(content));
+    } catch {
+    }
+  }
+  return updates.sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+  );
+}
+function getLatestUpdate(projectName) {
+  const updates = readUpdateFiles(projectName);
+  return updates[0] || null;
+}
+function getLatestByMachine(projectName) {
+  const updates = readUpdateFiles(projectName);
+  const byMachine = /* @__PURE__ */ new Map();
+  for (const update of updates) {
+    if (!byMachine.has(update.machine_id)) {
+      byMachine.set(update.machine_id, update);
+    }
+  }
+  return byMachine;
+}
+function getRecentUpdates(projectName, limit = 10) {
+  const updates = readUpdateFiles(projectName);
+  return updates.slice(0, limit);
+}
+
+// src/commands/sync.ts
+async function sync2(options = {}) {
+  if (!isInitialized()) {
+    if (!options.quiet) {
+      console.error('MindContext is not initialized. Run "mc init" first.');
+    }
+    process.exit(1);
+  }
+  const config2 = readConfig();
+  if (!config2) {
+    if (!options.quiet) {
+      console.error("Failed to read config.");
+    }
+    process.exit(1);
+  }
+  const projectPath = resolve2(process.cwd());
+  const projectName = basename3(projectPath);
+  const project = config2.projects[projectName];
+  if (!project) {
+    if (!options.quiet) {
+      console.error(`Project "${projectName}" is not connected.`);
+      console.error('Run "mc connect" first.');
+    }
+    process.exit(1);
+  }
+  const progress2 = getOpenSpecProgress(projectPath);
+  const context2 = {
+    current_task: progress2.change ? `Working on ${progress2.change}` : void 0,
+    status: options.status || (progress2.tasks_done > 0 ? "in_progress" : "idle"),
+    notes: options.notes || [],
+    next: options.next || []
+  };
+  if (!options.quiet) {
+    console.log(`Syncing "${projectName}"...`);
+    if (progress2.source === "openspec") {
+      console.log(`  Change: ${progress2.change}`);
+      console.log(`  Progress: ${progress2.tasks_done}/${progress2.tasks_total}`);
+    }
+  }
+  const recentCommits = getRecentCommits(projectPath, 5);
+  if (options.dryRun) {
+    if (!options.quiet) {
+      console.log("\n[Dry run] Would create update file:");
+      console.log(JSON.stringify({ progress: progress2, context: context2, recent_commits: recentCommits }, null, 2));
+    }
+    return;
+  }
+  const filepath = createUpdateFile(projectName, progress2, context2, recentCommits);
+  if (!options.quiet) {
+    console.log(`  Created: ${filepath}`);
+  }
+  const commitMessage = `chore(progress): sync ${config2.machine.name}`;
+  const result = sync(commitMessage);
+  if (!options.quiet) {
+    if (result.committed && result.pushed) {
+      console.log("\u2713 Synced successfully");
+    } else if (result.committed) {
+      console.log("\u2713 Committed locally (push pending)");
+      console.log('  Run "mc push" when online to push changes.');
+    } else {
+      console.log(`  ${result.message}`);
+    }
+  }
+}
+
+// src/commands/pull.ts
+async function pull2(options = {}) {
+  if (!isInitialized()) {
+    if (!options.quiet) {
+      console.error('MindContext is not initialized. Run "mc init" first.');
+    }
+    process.exit(1);
+  }
+  if (!options.quiet) {
+    console.log("Pulling latest updates...");
+  }
+  const result = pull();
+  if (!options.quiet) {
+    if (result.success) {
+      console.log("\u2713 Updated");
+      if (result.message && result.message !== "Already up to date.") {
+        console.log(`  ${result.message}`);
+      }
+    } else {
+      console.error("\u2717 Failed to pull");
+      console.error(`  ${result.message}`);
+    }
+  }
+}
+
+// src/commands/context.ts
+import { basename as basename4, resolve as resolve3 } from "path";
+async function context(options = {}) {
+  const projectPath = resolve3(process.cwd());
+  const projectName = basename4(projectPath);
+  const initialized = isInitialized();
+  const config2 = initialized ? readConfig() : null;
+  const project = config2?.projects[projectName];
+  const progress2 = getOpenSpecProgress(projectPath);
+  const percentage = progress2.tasks_total > 0 ? Math.round(progress2.tasks_done / progress2.tasks_total * 100) : 0;
+  const output = {
+    project: projectName,
+    connected: !!project,
+    progress: {
+      ...progress2,
+      percentage
+    },
+    team: []
+  };
+  if (project) {
+    const latestUpdate = getLatestUpdate(projectName);
+    if (latestUpdate) {
+      output.lastUpdate = {
+        timestamp: latestUpdate.timestamp,
+        machine: latestUpdate.machine,
+        status: latestUpdate.context.status,
+        notes: latestUpdate.context.notes,
+        next: latestUpdate.context.next
+      };
+    }
+    const byMachine = getLatestByMachine(projectName);
+    for (const [_machineId, update] of byMachine) {
+      output.team.push({
+        machine: update.machine,
+        timestamp: update.timestamp,
+        status: update.context.status
+      });
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+  if (!options.quiet) {
+    console.log(`Project: ${projectName}`);
+    console.log(`Connected: ${output.connected ? "Yes" : "No"}`);
+    console.log("");
+    if (progress2.source === "openspec" && progress2.change) {
+      console.log(`Change: ${progress2.change}`);
+      console.log(`Progress: ${progress2.tasks_done}/${progress2.tasks_total} (${percentage}%)`);
+    } else {
+      console.log("Progress: No active change");
+    }
+    if (output.lastUpdate) {
+      console.log("");
+      console.log(`Last Update: ${output.lastUpdate.timestamp}`);
+      console.log(`  Machine: ${output.lastUpdate.machine}`);
+      console.log(`  Status: ${output.lastUpdate.status}`);
+      if (output.lastUpdate.notes.length > 0) {
+        console.log(`  Notes: ${output.lastUpdate.notes.join(", ")}`);
+      }
+      if (output.lastUpdate.next.length > 0) {
+        console.log(`  Next: ${output.lastUpdate.next.join(", ")}`);
+      }
+    }
+    if (output.team.length > 1) {
+      console.log("");
+      console.log("Team Activity:");
+      for (const member of output.team) {
+        console.log(`  ${member.machine}: ${member.status} (${member.timestamp})`);
+      }
+    }
+  }
+}
+
+// src/commands/progress.ts
+import { execSync as execSync3 } from "child_process";
+import { basename as basename5, resolve as resolve4 } from "path";
+async function progress(options = {}) {
+  if (!isInitialized()) {
+    if (!options.quiet) {
+      console.error('MindContext is not initialized. Run "mc init" first.');
+    }
+    process.exit(1);
+  }
+  const config2 = readConfig();
+  if (!config2) {
+    if (!options.quiet) {
+      console.error("Failed to read config.");
+    }
+    process.exit(1);
+  }
+  if (options.web) {
+    if (!config2.dashboard_url) {
+      if (!options.quiet) {
+        console.error("No dashboard URL configured.");
+        console.error("Configure with: mc config --dashboard-url <url>");
+      }
+      process.exit(1);
+    }
+    if (!options.quiet) {
+      console.log(`Opening: ${config2.dashboard_url}`);
+    }
+    try {
+      const platform = process.platform;
+      if (platform === "darwin") {
+        execSync3(`open "${config2.dashboard_url}"`);
+      } else if (platform === "win32") {
+        execSync3(`start "${config2.dashboard_url}"`);
+      } else {
+        execSync3(`xdg-open "${config2.dashboard_url}"`);
+      }
+    } catch {
+      if (!options.quiet) {
+        console.log(`Please open: ${config2.dashboard_url}`);
+      }
+    }
+    return;
+  }
+  const projectPath = resolve4(process.cwd());
+  const projectName = basename5(projectPath);
+  const project = config2.projects[projectName];
+  if (!project) {
+    console.log("MindContext Progress\n");
+    console.log("Projects:");
+    for (const [name, proj] of Object.entries(config2.projects)) {
+      const openspecProgress2 = getOpenSpecProgress(proj.path);
+      const percentage2 = openspecProgress2.tasks_total > 0 ? Math.round(openspecProgress2.tasks_done / openspecProgress2.tasks_total * 100) : 0;
+      const bar = generateProgressBar(percentage2);
+      console.log(`  ${name}`);
+      console.log(`    ${bar} ${percentage2}%`);
+      if (openspecProgress2.change) {
+        console.log(`    Current: ${openspecProgress2.change}`);
+      }
+    }
+    if (Object.keys(config2.projects).length === 0) {
+      console.log("  (No projects connected)");
+      console.log("");
+      console.log('Run "mc connect" in a project directory to connect it.');
+    }
+    if (config2.dashboard_url) {
+      console.log("");
+      console.log(`Dashboard: ${config2.dashboard_url}`);
+      console.log('Run "mc progress --web" to open in browser.');
+    }
+    return;
+  }
+  const openspecProgress = getOpenSpecProgress(projectPath);
+  const percentage = openspecProgress.tasks_total > 0 ? Math.round(openspecProgress.tasks_done / openspecProgress.tasks_total * 100) : 0;
+  console.log(`${projectName}
+`);
+  if (openspecProgress.source === "openspec" && openspecProgress.change) {
+    console.log(`Change: ${openspecProgress.change}`);
+    console.log(`Progress: ${openspecProgress.tasks_done}/${openspecProgress.tasks_total}`);
+    console.log(generateProgressBar(percentage, 30) + ` ${percentage}%`);
+  } else {
+    console.log("No active OpenSpec change.");
+  }
+  const recentUpdates = getRecentUpdates(projectName, 5);
+  if (recentUpdates.length > 0) {
+    console.log("\nRecent Activity:");
+    for (const update of recentUpdates) {
+      const date = new Date(update.timestamp).toLocaleDateString();
+      const time = new Date(update.timestamp).toLocaleTimeString();
+      console.log(`  ${date} ${time} - ${update.machine}`);
+      if (update.context.notes.length > 0) {
+        console.log(`    Notes: ${update.context.notes.join(", ")}`);
+      }
+    }
+  }
+}
+function generateProgressBar(percentage, width = 20) {
+  const filled = Math.round(percentage / 100 * width);
+  const empty = width - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+}
+
+// src/commands/config.ts
+async function config(options) {
+  if (!isInitialized()) {
+    throw new Error('Mindcontext not initialized. Run "mc init" first.');
+  }
+  const currentConfig = readConfig();
+  if (!currentConfig) {
+    throw new Error("Failed to read config file.");
+  }
+  if (options.get) {
+    const key = options.get;
+    const value = currentConfig[key];
+    if (!options.quiet) {
+      if (typeof value === "object") {
+        console.log(JSON.stringify(value, null, 2));
+      } else {
+        console.log(value);
+      }
+    }
+    return value;
+  }
+  let updated = false;
+  if (options.dashboardRepo !== void 0) {
+    currentConfig.dashboard_repo = options.dashboardRepo;
+    updated = true;
+  }
+  if (options.dashboardUrl !== void 0) {
+    currentConfig.dashboard_url = options.dashboardUrl;
+    updated = true;
+  }
+  if (updated) {
+    writeConfig(currentConfig);
+    if (!options.quiet) {
+      console.log("\u2713 Config updated");
+    }
+    return currentConfig;
+  }
+  if (!options.quiet) {
+    console.log("Mindcontext Configuration:\n");
+    console.log(`  Dashboard Repo: ${currentConfig.dashboard_repo || "(not set)"}`);
+    console.log(`  Dashboard URL:  ${currentConfig.dashboard_url || "(not set)"}`);
+    console.log(`  Machine:        ${currentConfig.machine.name} (${currentConfig.machine.id})`);
+    console.log(`  Projects:       ${Object.keys(currentConfig.projects).length} registered`);
+  }
+  return currentConfig;
+}
+
+// src/commands/cleanup.ts
+import { readdirSync as readdirSync3, statSync, unlinkSync, existsSync as existsSync7 } from "fs";
+import { join as join5 } from "path";
+var DEFAULT_OLDER_THAN_DAYS = 30;
+async function cleanup(options) {
+  if (!isInitialized()) {
+    throw new Error('Mindcontext not initialized. Run "mc init" first.');
+  }
+  const config2 = readConfig();
+  if (!config2) {
+    throw new Error("Failed to read config file.");
+  }
+  const olderThanDays = options.olderThan ?? DEFAULT_OLDER_THAN_DAYS;
+  const cutoffTime = Date.now() - olderThanDays * 24 * 60 * 60 * 1e3;
+  const repoDir = getRepoDir();
+  let deleted = 0;
+  let wouldDelete = 0;
+  for (const projectName of Object.keys(config2.projects)) {
+    const updatesDir = join5(repoDir, "projects", projectName, "updates");
+    if (!existsSync7(updatesDir)) {
+      continue;
+    }
+    const files = readdirSync3(updatesDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      const filePath = join5(updatesDir, file);
+      const stats = statSync(filePath);
+      const fileAge = stats.mtime.getTime();
+      if (fileAge < cutoffTime) {
+        if (options.dryRun) {
+          wouldDelete++;
+          if (!options.quiet) {
+            console.log(`Would delete: ${projectName}/${file}`);
+          }
+        } else {
+          unlinkSync(filePath);
+          deleted++;
+          if (!options.quiet) {
+            console.log(`Deleted: ${projectName}/${file}`);
+          }
+        }
+      }
+    }
+  }
+  if (!options.quiet) {
+    if (options.dryRun) {
+      console.log(`
+${wouldDelete} file(s) would be deleted.`);
+    } else {
+      console.log(`
+\u2713 Cleaned up ${deleted} file(s).`);
+    }
+  }
+  return { deleted, wouldDelete };
+}
+
+// src/commands/reset.ts
+import { existsSync as existsSync8, rmSync } from "fs";
+async function reset(options) {
+  const mindcontextDir = getMindcontextDir();
+  if (!existsSync8(mindcontextDir)) {
+    if (!options.quiet) {
+      console.log("Nothing to remove. Mindcontext directory does not exist.");
+    }
+    return { success: true, removed: false };
+  }
+  if (options.dryRun) {
+    if (!options.quiet) {
+      console.log(`Would remove: ${mindcontextDir}`);
+      console.log("\nThis will delete:");
+      console.log("  - config.json (global configuration)");
+      console.log("  - repo/ (dashboard repository clone)");
+      console.log("  - All cached data and pending pushes");
+      console.log("\nRun with --force to actually remove.");
+    }
+    return { success: true, removed: false, wouldRemove: true };
+  }
+  if (!options.force) {
+    if (!options.quiet) {
+      console.log("Reset requires --force flag to confirm.");
+      console.log(`
+This will remove: ${mindcontextDir}`);
+      console.log("\nRun: mc reset --force");
+      console.log("Or preview with: mc reset --dry-run");
+    }
+    return { success: false, removed: false };
+  }
+  try {
+    rmSync(mindcontextDir, { recursive: true, force: true });
+    if (!options.quiet) {
+      console.log(`\u2713 Removed ${mindcontextDir}`);
+      console.log('\nRun "mc init" to set up mindcontext again.');
+    }
+    return { success: true, removed: true };
+  } catch (error) {
+    if (!options.quiet) {
+      console.error(`Failed to remove: ${error instanceof Error ? error.message : error}`);
+    }
+    return { success: false, removed: false };
+  }
+}
+
+// src/commands/migrate.ts
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, statSync as statSync2 } from "fs";
+import { join as join6, relative } from "path";
+function listFilesRecursively(dir, baseDir = dir) {
+  const files = [];
+  if (!existsSync9(dir)) {
+    return files;
+  }
+  const entries = readdirSync4(dir);
+  for (const entry of entries) {
+    const fullPath = join6(dir, entry);
+    const stat = statSync2(fullPath);
+    if (stat.isDirectory()) {
+      files.push(...listFilesRecursively(fullPath, baseDir));
+    } else {
+      files.push(relative(baseDir, fullPath));
+    }
+  }
+  return files;
+}
+function detectMigrationSources(projectPath) {
+  const projectDir = join6(projectPath, ".project");
+  const focusJsonPath = join6(projectPath, ".claude", "focus.json");
+  const hasProjectDir = existsSync9(projectDir);
+  const hasFocusJson = existsSync9(focusJsonPath);
+  const projectFiles = hasProjectDir ? listFilesRecursively(projectDir) : [];
+  return {
+    hasProjectDir,
+    hasFocusJson,
+    projectFiles,
+    focusJsonPath: hasFocusJson ? focusJsonPath : void 0
+  };
+}
+function convertFocusToUpdate(focusJson, projectName, machine) {
+  const timestamp = focusJson.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: "1.0",
+    timestamp,
+    machine: machine.name,
+    machine_id: machine.id,
+    project: projectName,
+    progress: {
+      source: "migration",
+      change: "migrated-from-focus",
+      tasks_done: 0,
+      tasks_total: 0
+    },
+    context: {
+      current_task: focusJson.current_focus || "",
+      status: "migrated",
+      notes: focusJson.session_summary ? [focusJson.session_summary] : [],
+      next: focusJson.next_session_tasks || []
+    }
+  };
+}
+async function migrate(options) {
+  if (!isInitialized()) {
+    throw new Error('Mindcontext not initialized. Run "mc init" first.');
+  }
+  const config2 = readConfig();
+  if (!config2) {
+    throw new Error("Failed to read config file.");
+  }
+  const sources = detectMigrationSources(options.projectPath);
+  if (!sources.hasProjectDir && !sources.hasFocusJson) {
+    if (!options.quiet) {
+      console.log("Nothing to migrate.");
+      console.log("  - No .project/ directory found");
+      console.log("  - No .claude/focus.json found");
+    }
+    return {
+      sources,
+      migrated: false,
+      focusMigrated: false,
+      projectDirMigrated: false
+    };
+  }
+  if (!options.quiet) {
+    console.log("Migration sources detected:\n");
+    if (sources.hasProjectDir) {
+      console.log("  .project/ directory:");
+      for (const file of sources.projectFiles) {
+        console.log(`    - ${file}`);
+      }
+    }
+    if (sources.hasFocusJson) {
+      console.log("  .claude/focus.json: Found");
+    }
+    console.log("");
+  }
+  if (options.dryRun) {
+    if (!options.quiet) {
+      console.log("Dry-run mode - no changes made.");
+      if (sources.hasFocusJson) {
+        console.log("\nWould migrate focus.json to update file.");
+      }
+      if (sources.hasProjectDir) {
+        console.log("\nWould prompt for .project/ file destinations.");
+      }
+    }
+    return {
+      sources,
+      migrated: false,
+      focusMigrated: false,
+      projectDirMigrated: false
+    };
+  }
+  let focusMigrated = false;
+  let projectDirMigrated = false;
+  if (sources.hasFocusJson && !options.skipFocusJson) {
+    if (!options.quiet) {
+      console.log("Migrating focus.json...");
+    }
+    try {
+      const projectName = Object.keys(config2.projects).find(
+        (name) => config2.projects[name].path === options.projectPath
+      ) || "unknown-project";
+      const focusContent = readFileSync4(sources.focusJsonPath, "utf8");
+      const focusJson = JSON.parse(focusContent);
+      const update = convertFocusToUpdate(focusJson, projectName, config2.machine);
+      ensureProjectDir(projectName);
+      const filename = generateUpdateFilename();
+      const updatesDir = getProjectDir(projectName);
+      const updatePath = join6(updatesDir, filename);
+      writeFileSync4(updatePath, JSON.stringify(update, null, 2));
+      if (!options.quiet) {
+        console.log(`  \u2713 Created update file: ${filename}`);
+      }
+      focusMigrated = true;
+    } catch (error) {
+      if (!options.quiet) {
+        console.error(`  \u2717 Failed to migrate focus.json: ${error instanceof Error ? error.message : error}`);
+      }
+    }
+  }
+  if (sources.hasProjectDir && !options.skipProjectDir) {
+    if (options.autoConfirm) {
+      if (!options.quiet) {
+        console.log("\n.project/ migration requires interactive mode.");
+        console.log("Run without --auto-confirm to migrate .project/ files.");
+      }
+    } else if (!options.quiet) {
+      console.log("\n.project/ migration: Interactive prompts not yet implemented.");
+      console.log("Files remain in .project/ - manual migration recommended.");
+    }
+  }
+  const migrated = focusMigrated || projectDirMigrated;
+  if (!options.quiet && migrated) {
+    console.log("\n\u2713 Migration complete.");
+  }
+  return {
+    sources,
+    migrated,
+    focusMigrated,
+    projectDirMigrated
+  };
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+var flags = {};
+var positional = [];
+for (let i = 1; i < args.length; i++) {
+  const arg = args[i];
+  if (arg.startsWith("--")) {
+    const eqIndex = arg.indexOf("=");
+    if (eqIndex > -1) {
+      const key = arg.slice(2, eqIndex);
+      const value = arg.slice(eqIndex + 1);
+      flags[key] = value;
+    } else {
+      const key = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        flags[key] = nextArg;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    }
+  } else if (arg.startsWith("-")) {
+    flags[arg.slice(1)] = true;
+  } else {
+    positional.push(arg);
+  }
+}
+async function main() {
+  try {
+    switch (command) {
+      case "init":
+        await init({ quiet: !!flags.quiet || !!flags.q });
+        break;
+      case "connect":
+        await connect({
+          category: flags.category,
+          name: positional[0],
+          quiet: !!flags.quiet || !!flags.q,
+          withHooks: !!flags["with-hooks"]
+        });
+        break;
+      case "sync":
+        await sync2({
+          quiet: !!flags.quiet || !!flags.q,
+          dryRun: !!flags["dry-run"],
+          notes: flags.notes ? String(flags.notes).split("\n").filter(Boolean) : void 0,
+          next: flags.next ? String(flags.next).split("\n").filter(Boolean) : void 0
+        });
+        break;
+      case "pull":
+        await pull2({ quiet: !!flags.quiet || !!flags.q });
+        break;
+      case "context":
+        await context({
+          json: !!flags.json,
+          quiet: !!flags.quiet || !!flags.q
+        });
+        break;
+      case "progress":
+        await progress({
+          web: !!flags.web,
+          quiet: !!flags.quiet || !!flags.q
+        });
+        break;
+      case "config":
+        await config({
+          show: !flags["dashboard-repo"] && !flags["dashboard-url"] && !flags.get,
+          get: flags.get,
+          dashboardRepo: flags["dashboard-repo"],
+          dashboardUrl: flags["dashboard-url"],
+          quiet: !!flags.quiet || !!flags.q
+        });
+        break;
+      case "cleanup":
+        await cleanup({
+          olderThan: flags["older-than"] ? parseInt(flags["older-than"], 10) : void 0,
+          dryRun: !!flags["dry-run"],
+          quiet: !!flags.quiet || !!flags.q
+        });
+        break;
+      case "reset":
+        await reset({
+          force: !!flags.force,
+          dryRun: !!flags["dry-run"],
+          quiet: !!flags.quiet || !!flags.q
+        });
+        break;
+      case "migrate":
+        await migrate({
+          projectPath: process.cwd(),
+          dryRun: !!flags["dry-run"],
+          quiet: !!flags.quiet || !!flags.q,
+          skipProjectDir: !!flags["skip-project"],
+          skipFocusJson: !!flags["skip-focus"],
+          autoConfirm: !!flags.yes || !!flags.y
+        });
+        break;
+      case "help":
+      case "--help":
+      case "-h":
+      case void 0:
+        printHelp();
+        break;
+      case "version":
+      case "--version":
+      case "-v":
+        console.log("mindcontext v0.1.0");
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.error('Run "mc help" for available commands.');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`
+mindcontext - Git-based project progress tracker
+
+USAGE:
+  mc <command> [options]
+
+COMMANDS:
+  init              Initialize mindcontext (~/.mindcontext/)
+  connect           Connect current project to mindcontext
+  sync              Create progress update and push
+  pull              Pull latest updates from remote
+  context           Output current context (for integration)
+  progress          Show progress (or --web to open dashboard)
+  config            View or update configuration
+  cleanup           Remove old update files
+  reset             Remove ~/.mindcontext/ and start fresh
+  migrate           Migrate from .project/ and focus.json
+  help              Show this help message
+
+OPTIONS:
+  --quiet, -q       Suppress output
+  --json            Output as JSON (context command)
+  --web             Open web dashboard (progress command)
+  --category        Set project category (connect command)
+  --with-hooks      Generate session-end hook (connect command)
+  --dry-run         Show what would be done (sync command)
+  --dashboard-repo  Set dashboard git repository (config command)
+  --dashboard-url   Set dashboard web URL (config command)
+  --get <key>       Get specific config value (config command)
+  --older-than <d>  Days threshold for cleanup (default: 30)
+  --force           Confirm destructive action (reset command)
+  --yes, -y         Auto-confirm prompts (migrate command)
+  --skip-project    Skip .project/ migration
+  --skip-focus      Skip focus.json migration
+
+EXAMPLES:
+  # First-time setup
+  mc init
+
+  # Connect a project
+  cd my-project
+  mc connect --category work
+
+  # Daily usage
+  mc sync              # Push progress update
+  mc progress          # View progress in terminal
+  mc progress --web    # Open dashboard in browser
+  mc pull              # Get team updates
+
+DOCUMENTATION:
+  https://github.com/tmsjngx0/mindcontext
+`);
+}
+main();
+//# sourceMappingURL=cli.js.map