Function saveCommand

devctx/src/commands/save.ts:28–183

(message?: string, options?: SaveOptions)

}

export async function saveCommand(message?: string, options?: SaveOptions) {
  if (!(await isInitialized())) {
    console.log(chalk.red("✗ DevContext not initialized. Run `devctx init` first."));
    return;
  }

  try {
    const [branch, repo, filesChanged, filesStaged, recentCommits, author] = await Promise.all([
      getCurrentBranch(),
      getRepoName(),
      getChangedFiles(),
      getStagedFiles(),
      getRecentCommits(),
      getAuthor(),
    ]);

    let task = message || "";
    let approaches: string[] = [];
    let decisions: string[] = [];
    let currentState = "";
    let nextSteps: string[] = [];
    let blockers: string[] = [];

    // Check if structured flags were provided (AI agent mode)
    const hasStructuredInput =
      options?.approaches || options?.decisions || options?.state || options?.nextSteps;

    if (options?.auto) {
      // Auto-extract mode — read from editor session data
      console.log(chalk.gray("  Scanning editor sessions for context..."));
      const cwd = process.cwd();
      const extracted = await extractFromEditorSessions(cwd);

      if (extracted) {
        task = message || extracted.task;
        approaches = extracted.approaches;
        decisions = extracted.decisions;
        currentState = extracted.currentState;
        nextSteps = extracted.nextSteps;
        blockers = extracted.blockers;
        console.log(chalk.gray(`  Found context from: ${extracted.source}`));
      } else {
        console.log(chalk.yellow("⚠ No editor session data found. Using message only."));
        task = message || "Session (auto-extract found nothing)";
        currentState = message || "";
      }
    } else if (hasStructuredInput && message) {
      // Programmatic mode — AI agent is passing structured context
      task = message;
      approaches = options?.approaches
        ? options.approaches.split(";;").map((s) => s.trim()).filter(Boolean)
        : [];
      decisions = options?.decisions
        ? options.decisions.split(";;").map((s) => s.trim()).filter(Boolean)
        : [];
      currentState = options?.state || message;
      nextSteps = options?.nextSteps
        ? options.nextSteps.split(";;").map((s) => s.trim()).filter(Boolean)