share-the-mark 0.2.0

share-the-mark CLI: receive design-feedback change-briefs from the browser extension and expose them to a coding agent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::path::PathBuf;

use anyhow::{anyhow, Result};
use clap::{Args, Parser, Subcommand};

#[derive(Parser)]
#[command(
    name = "share-the-mark",
    version,
    about = "share-the-mark: receive design-feedback change-briefs and expose them to a coding agent"
)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Command,
}

#[derive(Subcommand)]
pub enum Command {
    /// Run the ingest daemon in the foreground (Ctrl-C to stop).
    Serve(ServeArgs),
    /// Start the ingest daemon in the background.
    Start(ServeArgs),
    /// Stop the background daemon.
    Stop {
        #[arg(long)]
        port: Option<u16>,
    },
    /// Report whether the daemon is running.
    Status {
        #[arg(long)]
        port: Option<u16>,
    },
    /// List briefs that haven't been read yet.
    Pending {
        #[arg(long)]
        dir: Option<PathBuf>,
    },
    /// List recent briefs (use --all for every brief).
    List {
        #[arg(long)]
        all: bool,
        #[arg(long)]
        dir: Option<PathBuf>,
    },
    /// Print a brief's Markdown and screenshot path (marks it read).
    Show {
        /// Brief id, as shown by `share-the-mark pending` / `share-the-mark list`.
        id: String,
        #[arg(long)]
        json: bool,
        #[arg(long)]
        keep_unread: bool,
        #[arg(long)]
        dir: Option<PathBuf>,
    },
    /// Open a page for annotation and wait for the user's feedback (for agents).
    Request {
        /// URL to open in the browser for annotation.
        url: String,
        #[arg(long)]
        json: bool,
        /// How long to wait for feedback before giving up.
        #[arg(long, default_value_t = 600)]
        timeout: u64,
        #[arg(long)]
        port: Option<u16>,
        #[arg(long)]
        dir: Option<PathBuf>,
    },
    /// Manage the bundled Claude Code skill.
    Skill {
        #[command(subcommand)]
        command: SkillCommand,
    },
}

#[derive(Args)]
pub struct ServeArgs {
    #[arg(long)]
    pub port: Option<u16>,
    #[arg(long)]
    pub dir: Option<PathBuf>,
    /// Shut down after this many seconds with no activity (0 = never).
    #[arg(long)]
    pub idle_timeout: Option<u64>,
}

#[derive(Subcommand)]
pub enum SkillCommand {
    /// Install the skill (defaults to the per-OS Claude skills directory).
    Install {
        #[arg(long)]
        dir: Option<PathBuf>,
    },
}

/// Port precedence: flag → `SHARE_THE_MARK_PORT` → 8787.
pub fn resolve_port(flag: Option<u16>) -> u16 {
    flag.or_else(|| {
        std::env::var("SHARE_THE_MARK_PORT")
            .ok()
            .and_then(|s| s.parse().ok())
    })
    .unwrap_or(8787)
}

/// Idle-timeout precedence: flag → `SHARE_THE_MARK_IDLE` → 0 (never). Seconds.
pub fn resolve_idle(flag: Option<u64>) -> u64 {
    flag.or_else(|| {
        std::env::var("SHARE_THE_MARK_IDLE")
            .ok()
            .and_then(|s| s.parse().ok())
    })
    .unwrap_or(0)
}

/// Store dir precedence: flag → `SHARE_THE_MARK_DIR` → per-OS data directory.
pub fn resolve_dir(flag: Option<PathBuf>) -> Result<PathBuf> {
    if let Some(dir) = flag {
        return Ok(dir);
    }
    if let Ok(dir) = std::env::var("SHARE_THE_MARK_DIR") {
        return Ok(PathBuf::from(dir));
    }
    let project = directories::ProjectDirs::from("", "", "share-the-mark")
        .ok_or_else(|| anyhow!("cannot determine a data directory"))?;
    Ok(project.data_dir().to_path_buf())
}