@codefilabs/tq 0.0.2 → 0.1.1

package/scripts/tq-cron-sync

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Ensure homebrew binaries are available (cron has minimal PATH)
+export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
+
+INTERVAL=20
+
+while [[ $# -gt 0 ]]; do
+  case "${1:-}" in
+    --interval)
+      if [[ $# -lt 2 ]]; then
+        echo "Error: --interval requires a value" >&2; exit 1
+      fi
+      INTERVAL="$2"; shift; shift ;;
+    *) echo "Unknown flag: $1" >&2; exit 1 ;;
+  esac
+done
+
+QUEUES_DIR="${HOME}/.tq/queues"
+LOGS_DIR="${HOME}/.tq/logs"
+mkdir -p "$QUEUES_DIR" "$LOGS_DIR"
+
+# ---------------------------------------------------------------------------
+# Scan ~/.tq/queues/*.yaml for schedule: keys via embedded Python temp file
+# ---------------------------------------------------------------------------
+SCAN_SCRIPT=$(mktemp /tmp/tq-scan-XXXXXX)
+CRONTAB_NEW=$(mktemp /tmp/tq-crontab-XXXXXX)
+trap 'rm -f "$SCAN_SCRIPT" "$CRONTAB_NEW"' EXIT
+
+cat > "$SCAN_SCRIPT" <<'PYEOF'
+import sys, os, re, json, glob
+
+queues_dir = sys.argv[1]
+results = []
+
+for yaml_path in sorted(glob.glob(os.path.join(queues_dir, '*.yaml'))):
+    name = os.path.basename(yaml_path)[:-5]  # strip .yaml
+    schedule = None
+    try:
+        with open(yaml_path) as f:
+            for line in f:
+                m = re.match(r'^schedule:\s*["\']?([^"\'#\n]+?)["\']?\s*$', line)
+                if m:
+                    schedule = m.group(1).strip()
+                    break
+    except Exception:
+        pass
+    if schedule:
+        results.append({'name': name, 'schedule': schedule, 'path': yaml_path})
+
+for r in results:
+    print(json.dumps(r))
+PYEOF
+
+# ---------------------------------------------------------------------------
+# Detect installed tq binary path
+# ---------------------------------------------------------------------------
+if [[ -x "/opt/homebrew/bin/tq" ]]; then
+  TQ_BIN="/opt/homebrew/bin/tq"
+  SELF_BIN="/opt/homebrew/bin/tq-cron-sync"
+elif [[ -x "/usr/local/bin/tq" ]]; then
+  TQ_BIN="/usr/local/bin/tq"
+  SELF_BIN="/usr/local/bin/tq-cron-sync"
+else
+  echo "Error: tq not found in /opt/homebrew/bin or /usr/local/bin" >&2
+  exit 1
+fi
+
+# ---------------------------------------------------------------------------
+# Read existing crontab, strip all tq-managed lines into temp file
+# ---------------------------------------------------------------------------
+{ crontab -l 2>/dev/null || true; } | grep -v '# tq-managed:' > "$CRONTAB_NEW" || true
+
+# ---------------------------------------------------------------------------
+# Append new managed lines for each scheduled queue
+# ---------------------------------------------------------------------------
+while IFS= read -r JSON_LINE; do
+  [[ -z "$JSON_LINE" ]] && continue
+  NAME="$(python3 -c "import sys,json; print(json.loads(sys.argv[1])['name'])" "$JSON_LINE")"
+  SCHEDULE="$(python3 -c "import sys,json; print(json.loads(sys.argv[1])['schedule'])" "$JSON_LINE")"
+  YAML_PATH="$(python3 -c "import sys,json; print(json.loads(sys.argv[1])['path'])" "$JSON_LINE")"
+  echo "${SCHEDULE} ${TQ_BIN} ${YAML_PATH} >> ${LOGS_DIR}/tq.log 2>&1 # tq-managed:${NAME}:run" >> "$CRONTAB_NEW"
+  echo "*/30 * * * * ${TQ_BIN} --status ${YAML_PATH} >> ${LOGS_DIR}/tq.log 2>&1 # tq-managed:${NAME}:status" >> "$CRONTAB_NEW"
+done < <(python3 "$SCAN_SCRIPT" "$QUEUES_DIR")
+
+# Self-watcher entry
+echo "*/${INTERVAL} * * * * ${SELF_BIN} >> ${LOGS_DIR}/tq-cron-sync.log 2>&1 # tq-managed:tq-cron-sync" >> "$CRONTAB_NEW"
+
+# Write merged crontab
+crontab "$CRONTAB_NEW"
+echo "tq-cron-sync: crontab synced ($(grep -c '# tq-managed:' "$CRONTAB_NEW" || true) managed entries)"

package/scripts/tq-install.sh

@@ -5,10 +5,10 @@ set -euo pipefail
 # Step 1: Register marketplace and install Claude plugin
 # ---------------------------------------------------------------------------
 if command -v claude &>/dev/null; then
-  echo "Adding tq marketplace..."
-  claude plugin marketplace add kevnk/tq
+  echo "Adding codefilabs marketplace..."
+  claude plugin marketplace add codefilabs/marketplace
   echo "Installing tq plugin..."
-  claude plugin install tq@tq
+  claude plugin install tq@codefilabs
 else
   echo "Warning: 'claude' CLI not found — skipping plugin registration." >&2
   echo "  Install Claude Code first: https://claude.ai/code" >&2
@@ -24,11 +24,11 @@ elif [[ -n "${BASH_SOURCE[0]:-}" && -f "${BASH_SOURCE[0]}" ]]; then
   PLUGIN_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 else
   # Running via curl | bash — find the installed plugin cache
-  CACHE_DIR="$HOME/.claude/plugins/cache/tq/tq"
+  CACHE_DIR="$HOME/.claude/plugins/cache/tq/codefilabs"
   PLUGIN_ROOT="$(ls -d "$CACHE_DIR"/*/ 2>/dev/null | sort -V | tail -1)"
   if [[ -z "${PLUGIN_ROOT:-}" ]]; then
     echo "Error: could not locate tq plugin files in $CACHE_DIR" >&2
-    echo "  Try running: claude plugin marketplace add kevnk/tq && claude plugin install tq@tq" >&2
+    echo "  Try running: claude plugin marketplace add codefilabs/marketplace && claude plugin install tq@codefilabs" >&2
     exit 1
   fi
 fi
@@ -48,7 +48,7 @@ else
   exit 1
 fi
 
-for SCRIPT in tq tq-message tq-setup tq-telegram-poll tq-telegram-watchdog; do
+for SCRIPT in tq tq-message tq-setup tq-telegram-poll tq-telegram-watchdog tq-cron-sync tq-converse; do
   SRC="$PLUGIN_ROOT/scripts/$SCRIPT"
   DEST="$INSTALL_DIR/$SCRIPT"
   if [[ -L "$DEST" ]]; then
@@ -63,16 +63,80 @@ done
 
 mkdir -p ~/.tq/queues ~/.tq/logs ~/.tq/config
 
+# Run initial cron sync to pick up any existing queue schedules
+# Use $INSTALL_DIR directly — PATH may not reflect the just-created symlink yet
+"$INSTALL_DIR/tq-cron-sync" --interval 20
+
+# ---------------------------------------------------------------------------
+# Step 4: Set up Telegram long-poll daemon via launchd (if bot is configured)
+# ---------------------------------------------------------------------------
+PLIST_LABEL="com.codefi.tq-telegram"
+PLIST_PATH="$HOME/Library/LaunchAgents/${PLIST_LABEL}.plist"
+
+if [[ -f "$HOME/.tq/config/message.yaml" ]] && grep -q 'bot_token' "$HOME/.tq/config/message.yaml" 2>/dev/null; then
+  # Remove old cron-based poll entries (replaced by launchd daemon)
+  CRONTAB_CURRENT="$(crontab -l 2>/dev/null || true)"
+  if echo "$CRONTAB_CURRENT" | grep -q 'tq-telegram-poll'; then
+    echo "$CRONTAB_CURRENT" | grep -v 'tq-telegram-poll' | grep -v 'tq-telegram-watchdog' | crontab -
+    echo "  removed cron-based telegram poll (replaced by launchd daemon)"
+  fi
+
+  cat > "$PLIST_PATH" <<PLISTEOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${INSTALL_DIR}/tq-telegram-poll</string>
+    <string>--daemon</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${HOME}/.tq/logs/tq-telegram.log</string>
+  <key>StandardErrorPath</key>
+  <string>${HOME}/.tq/logs/tq-telegram.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+</dict>
+</plist>
+PLISTEOF
+
+  # (Re)load the daemon
+  launchctl bootout "gui/$(id -u)/${PLIST_LABEL}" 2>/dev/null || true
+  launchctl bootstrap "gui/$(id -u)" "$PLIST_PATH"
+  echo "  telegram daemon started (launchd: ${PLIST_LABEL})"
+else
+  echo ""
+  echo "Telegram bot not configured yet. After running tq-setup, re-run this"
+  echo "installer to start the long-poll daemon automatically."
+fi
+
+echo ""
+echo "tq installed. Cron schedules are managed automatically."
+echo ""
+echo "Add a schedule: key to any queue file in ~/.tq/queues/ to auto-schedule it:"
 echo ""
-echo "tq installed. Crontab example (crontab -e):"
+echo "  schedule: \"0 9 * * *\"   # runs daily at 9am"
+echo "  cwd: /path/to/project"
+echo "  tasks: ..."
 echo ""
-echo "  0 9 * * * /opt/homebrew/bin/tq ~/.tq/queues/morning.yaml >> ~/.tq/logs/tq.log 2>&1"
-echo "  */30 * * * * /opt/homebrew/bin/tq --status ~/.tq/queues/morning.yaml >> ~/.tq/logs/tq.log 2>&1"
+echo "tq-cron-sync runs every 20 minutes and syncs all queue schedules to crontab."
+echo "To change the sync interval: tq-cron-sync --interval <minutes>"
 echo ""
 echo "To configure Telegram notifications:"
 echo "  tq-setup"
 echo ""
 echo "Or from Claude Code: /setup-telegram"
 echo ""
-echo "To relay Telegram messages as tq tasks, add to crontab:"
-echo "  * * * * * /opt/homebrew/bin/tq-telegram-poll >> ~/.tq/logs/tq-telegram.log 2>&1"
+echo "Conversation mode (interactive Telegram <-> Claude Code):"
+echo "  tq-converse start [--cwd /path/to/project]"
+echo "  Or send /converse from Telegram"

package/scripts/tq-message

@@ -8,6 +8,7 @@ QUEUE_FILE=""
 MESSAGE_TEXT=""
 SESSION=""
 EXPLICIT_STATE_FILE=""
+REPLY_TO_MSG_ID=""
 
 while [[ $# -gt 0 ]]; do
   case "${1:-}" in
@@ -16,15 +17,18 @@ while [[ $# -gt 0 ]]; do
     --message)    MESSAGE_TEXT="${2:-}";       shift 2 ;;
     --session)    SESSION="${2:-}";            shift 2 ;;
     --state-file) EXPLICIT_STATE_FILE="${2:-}"; shift 2 ;;
+    --reply-to)   REPLY_TO_MSG_ID="${2:-}";    shift 2 ;;
     --) shift; break ;;
     -*) echo "Unknown flag: $1" >&2; exit 1 ;;
     *)  break ;;
   esac
 done
 
-if [[ -z "$TASK_HASH" && -z "$QUEUE_FILE" ]]; then
+# Allow --message without --task/--queue (conversation mode)
+if [[ -z "$TASK_HASH" && -z "$QUEUE_FILE" && -z "$MESSAGE_TEXT" ]]; then
   echo "Usage: tq-message --task <hash> --queue <file.yaml> [--message <text>] [--session <name>]" >&2
   echo "       tq-message --queue <file.yaml> [--message <text>]" >&2
+  echo "       tq-message --message <text> [--reply-to <msg_id>]" >&2
   exit 1
 fi
 
@@ -36,7 +40,7 @@ if [[ -n "$QUEUE_FILE" ]]; then
   fi
 fi
 
-CONFIG_SCRIPT=$(mktemp /tmp/tq-message-config-XXXXXX.py)
+CONFIG_SCRIPT=$(mktemp /tmp/tq-message-config-XXXXXX)
 trap 'rm -f "$CONFIG_SCRIPT"' EXIT
 
 cat > "$CONFIG_SCRIPT" <<'PYEOF'
@@ -165,21 +169,25 @@ build_message() {
   if [[ -f "$state_file" ]]; then
     status="$(grep '^status=' "$state_file" | cut -d= -f2)"
     started="$(grep '^started=' "$state_file" | cut -d= -f2)"
+    completed_epoch="$(grep '^completed=' "$state_file" | cut -d= -f2)"
   else
     status="done"
     started=""
+    completed_epoch=""
   fi
 
-  # Calculate duration in minutes
+  # Calculate duration using completed epoch (avoids timezone skew from ISO string parsing)
   duration=""
   if [[ -n "$started" ]]; then
-    start_epoch="$(python3 -c "import datetime; print(int(datetime.datetime.fromisoformat('${started}').timestamp()))" 2>/dev/null || echo "")"
-    if [[ -n "$start_epoch" ]]; then
-      now_epoch="$(date +%s)"
-      elapsed=$(( now_epoch - start_epoch ))
-      duration="${elapsed}s"
-      if (( elapsed >= 60 )); then
-        duration="$(( elapsed / 60 ))m $(( elapsed % 60 ))s"
+    start_epoch="$(date -j -f "%Y-%m-%dT%H:%M:%S" "${started}" "+%s" 2>/dev/null || echo "")"
+    end_epoch="${completed_epoch:-$(date +%s)}"
+    if [[ -n "$start_epoch" && -n "$end_epoch" ]]; then
+      elapsed=$(( end_epoch - start_epoch ))
+      if (( elapsed > 0 )); then
+        duration="${elapsed}s"
+        if (( elapsed >= 60 )); then
+          duration="$(( elapsed / 60 ))m $(( elapsed % 60 ))s"
+        fi
       fi
     fi
   fi
@@ -271,16 +279,50 @@ send_telegram() {
   local token="$1"
   local chat_id="$2"
   local text="$3"
+  local reply_to="${4:-}"
+
+  local curl_args=()
+  curl_args+=(-s -X POST "https://api.telegram.org/bot${token}/sendMessage")
+  curl_args+=(-d "chat_id=${chat_id}")
+  curl_args+=(--data-urlencode "text=${text}")
+  curl_args+=(-d "parse_mode=Markdown")
+
+  # Add reply threading if a reply_to message ID is provided
+  if [[ -n "$reply_to" ]]; then
+    curl_args+=(-d "reply_to_message_id=${reply_to}")
+    curl_args+=(-d "allow_sending_without_reply=true")
+  fi
 
   local response
-  response="$(curl -s -X POST \
-    "https://api.telegram.org/bot${token}/sendMessage" \
-    -d "chat_id=${chat_id}" \
-    --data-urlencode "text=${text}" \
-    -d "parse_mode=Markdown" 2>&1)"
-
-  if echo "$response" | python3 -c "import sys,json; d=json.load(sys.stdin); exit(0 if d.get('ok') else 1)" 2>/dev/null; then
-    echo "[tq-message] sent via Telegram"
+  response="$(curl "${curl_args[@]}" 2>&1)"
+
+  # Extract the sent message ID for reply threading tracking
+  local sent_msg_id
+  sent_msg_id="$(echo "$response" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    if d.get('ok'):
+        print(d.get('result', {}).get('message_id', ''))
+    else:
+        sys.exit(1)
+except:
+    sys.exit(1)
+" 2>/dev/null || true)"
+
+  if [[ -n "$sent_msg_id" ]]; then
+    echo "[tq-message] sent via Telegram (msg_id=$sent_msg_id)"
+    # Track outgoing message ID in registry for reply threading
+    if [[ -n "$sent_msg_id" ]] && command -v tq-converse &>/dev/null; then
+      # Try to detect which slug this message belongs to
+      local slug_file="$HOME/.tq/conversations/latest-reply-slug"
+      if [[ -f "$slug_file" ]]; then
+        local slug
+        slug="$(cat "$slug_file")"
+        tq-converse track-msg "$slug" "$sent_msg_id" 2>/dev/null || true
+        rm -f "$slug_file"
+      fi
+    fi
   else
     echo "[tq-message] Telegram error: $response" >&2
     exit 1
@@ -290,29 +332,56 @@ send_telegram() {
 deliver() {
   local service="$1"
   local msg="$2"
+  local reply_to="${3:-}"
   case "$service" in
-    telegram) send_telegram "$TG_TOKEN" "$TG_CHAT" "$msg" ;;
+    telegram) send_telegram "$TG_TOKEN" "$TG_CHAT" "$msg" "$reply_to" ;;
     *) echo "[tq-message] unknown service: $service" >&2; exit 1 ;;
   esac
 }
 
-# Summary mode with a live session: ask Claude to generate and send
+# Summary mode with a live session: ask Claude to write summary via slash command
 if [[ "$CONTENT" == "summary" && -n "$SESSION" && -z "$MESSAGE_TEXT" ]]; then
   if tmux has-session -t "$SESSION" 2>/dev/null; then
-    # Pass hash and queue path as arguments to the slash command
+    HANDSHAKE_FILE="/tmp/tq-summary-${TASK_HASH}.txt"
+    rm -f "$HANDSHAKE_FILE"
+
+    # Tell Claude to generate summary (slash command calls tq-message --message which writes handshake file + delivers)
     tmux send-keys -t "$SESSION" "/tq-message ${TASK_HASH} ${QUEUE_FILE}" Enter
-    # Give Claude time to summarize and call back tq-message --message
-    sleep 45
-    # Close the session
-    tmux send-keys -t "$SESSION" "" Enter
-    exit 0
+
+    # Poll for the handshake file (max 90 seconds, check every 3s)
+    WAITED=0
+    while [[ ! -f "$HANDSHAKE_FILE" && "$WAITED" -lt 90 ]]; do
+      sleep 3
+      WAITED=$(( WAITED + 3 ))
+    done
+
+    if [[ -f "$HANDSHAKE_FILE" ]]; then
+      # Slash command already delivered the message — just clean up
+      rm -f "$HANDSHAKE_FILE"
+      exit 0
+    else
+      # Timed out — fall back to details
+      MESSAGE_TEXT="$(build_message "details" "$TASK_HASH" "$STATE_FILE" "$PROMPT_FILE" "")"
+    fi
   else
     # Session gone — fall back to details
     MESSAGE_TEXT="$(build_message "details" "$TASK_HASH" "$STATE_FILE" "$PROMPT_FILE" "")"
   fi
 fi
 
+# Write handshake file for summary polling (if applicable)
+if [[ -n "$MESSAGE_TEXT" && -n "$TASK_HASH" ]]; then
+  echo "$MESSAGE_TEXT" > "/tmp/tq-summary-${TASK_HASH}.txt"
+fi
+
 # Deliver message if we have one
 if [[ -n "$MESSAGE_TEXT" ]]; then
-  deliver "$SERVICE" "$MESSAGE_TEXT"
+  # If no explicit reply-to, check for latest-msg-id (conversation mode)
+  if [[ -z "$REPLY_TO_MSG_ID" ]]; then
+    LATEST_MSG_FILE="$HOME/.tq/conversations/latest-msg-id"
+    if [[ -f "$LATEST_MSG_FILE" ]]; then
+      REPLY_TO_MSG_ID="$(cat "$LATEST_MSG_FILE")"
+    fi
+  fi
+  deliver "$SERVICE" "$MESSAGE_TEXT" "$REPLY_TO_MSG_ID"
 fi

package/scripts/tq-setup

@@ -32,7 +32,7 @@ read -r _IGNORED
 
 UPDATES="$(curl -s "https://api.telegram.org/bot${BOT_TOKEN}/getUpdates?offset=0&limit=10&timeout=0" 2>&1)"
 
-DISCOVER_SCRIPT=$(mktemp /tmp/tq-setup-discover-XXXXXX.py)
+DISCOVER_SCRIPT=$(mktemp /tmp/tq-setup-discover-XXXXXX)
 trap 'rm -f "$DISCOVER_SCRIPT"' EXIT
 
 cat > "$DISCOVER_SCRIPT" <<'PYEOF'