mindcontext-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,978 @@
+// 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(config) {
+  if (!existsSync(MINDCONTEXT_DIR)) {
+    mkdirSync(MINDCONTEXT_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, 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 config2 = readConfig();
+    if (!options.quiet) {
+      console.log("MindContext is already initialized.");
+      console.log(`  Directory: ${mindcontextDir}`);
+      console.log(`  Dashboard: ${config2?.dashboard_url || "Not configured"}`);
+      console.log(`  Projects: ${Object.keys(config2?.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 config2 = createDefaultConfig();
+    writeConfig(config2);
+    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 config = createDefaultConfig();
+  config.dashboard_repo = dashboardRepo;
+  config.dashboard_url = dashboardUrl;
+  writeConfig(config);
+  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 config = readConfig();
+  if (!config) {
+    console.error("Failed to read config.");
+    process.exit(1);
+  }
+  const projectPath = resolve(process.cwd());
+  const projectName = options.name || basename2(projectPath);
+  if (config.projects[projectName]) {
+    if (!options.quiet) {
+      console.log(`Project "${projectName}" is already connected.`);
+      console.log(`  Path: ${config.projects[projectName].path}`);
+      console.log(`  Category: ${config.projects[projectName].category}`);
+      console.log(`  OpenSpec: ${config.projects[projectName].openspec ? "Yes" : "No"}`);
+    }
+    return;
+  }
+  const openspec = hasOpenSpec(projectPath);
+  config.projects[projectName] = {
+    path: projectPath,
+    openspec,
+    category: options.category || "default"
+  };
+  writeConfig(config);
+  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 config = readConfig();
+  if (!config) {
+    if (!options.quiet) {
+      console.error("Failed to read config.");
+    }
+    process.exit(1);
+  }
+  const projectPath = resolve2(process.cwd());
+  const projectName = basename3(projectPath);
+  const project = config.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 ${config.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 config = initialized ? readConfig() : null;
+  const project = config?.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 config = readConfig();
+  if (!config) {
+    if (!options.quiet) {
+      console.error("Failed to read config.");
+    }
+    process.exit(1);
+  }
+  if (options.web) {
+    if (!config.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: ${config.dashboard_url}`);
+    }
+    try {
+      const platform = process.platform;
+      if (platform === "darwin") {
+        execSync3(`open "${config.dashboard_url}"`);
+      } else if (platform === "win32") {
+        execSync3(`start "${config.dashboard_url}"`);
+      } else {
+        execSync3(`xdg-open "${config.dashboard_url}"`);
+      }
+    } catch {
+      if (!options.quiet) {
+        console.log(`Please open: ${config.dashboard_url}`);
+      }
+    }
+    return;
+  }
+  const projectPath = resolve4(process.cwd());
+  const projectName = basename5(projectPath);
+  const project = config.projects[projectName];
+  if (!project) {
+    console.log("MindContext Progress\n");
+    console.log("Projects:");
+    for (const [name, proj] of Object.entries(config.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(config.projects).length === 0) {
+      console.log("  (No projects connected)");
+      console.log("");
+      console.log('Run "mc connect" in a project directory to connect it.');
+    }
+    if (config.dashboard_url) {
+      console.log("");
+      console.log(`Dashboard: ${config.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);
+}
+export {
+  connect,
+  context,
+  createUpdateFile,
+  generateUpdateFilename,
+  getLatestByMachine,
+  getLatestUpdate,
+  getMachineId,
+  getMindcontextDir,
+  getOpenSpecProgress,
+  getRepoDir,
+  getTimestamp,
+  hasOpenSpec,
+  init,
+  isInitialized,
+  parseOpenSpec,
+  progress,
+  pull2 as pull,
+  readConfig,
+  readUpdateFiles,
+  sync2 as sync,
+  writeConfig
+};
+//# sourceMappingURL=index.js.map