zillacore 0.0.1

data/lib/zillacore/sessions.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+# Session tracking, deduplication, cooldowns, and agent dispatch depth.
+
+# --- Deduplication ---
+
+PROCESSED_EVENTS = {}
+PROCESSED_EVENTS_MAX = 1000
+
+def already_processed?(event_id)
+  return false unless event_id
+  return true if PROCESSED_EVENTS[event_id]
+
+  PROCESSED_EVENTS[event_id] = Time.now
+  if PROCESSED_EVENTS.size > PROCESSED_EVENTS_MAX
+    oldest = PROCESSED_EVENTS.keys.first(PROCESSED_EVENTS.size - PROCESSED_EVENTS_MAX)
+    oldest.each { |k| PROCESSED_EVENTS.delete(k) }
+  end
+  false
+end
+
+# --- Active sessions ---
+
+ACTIVE_SESSIONS = {}
+ACTIVE_SESSIONS_MUTEX = Mutex.new
+RECENT_SESSIONS = []
+RECENT_SESSIONS_MAX = 10
+
+# --- Self-move tracking (suppress webhook echoes from our own column moves) ---
+
+SELF_MOVES = {}
+SELF_MOVES_MUTEX = Mutex.new
+
+def record_self_move(card_number)
+  SELF_MOVES_MUTEX.synchronize { SELF_MOVES[card_number.to_s] = Time.now }
+end
+
+def self_move_recent?(card_number, window: 120)
+  SELF_MOVES_MUTEX.synchronize do
+    t = SELF_MOVES[card_number.to_s]
+    t && (Time.now - t) < window
+  end
+end
+
+# Archive a completed session for menu bar display. Call inside ACTIVE_SESSIONS_MUTEX.
+def archive_session(card_key, info)
+  RECENT_SESSIONS.unshift({
+                            card_key: card_key, agent_name: info[:agent_name],
+                            log_file: info[:log_file], started_at: info[:started_at],
+                            finished_at: Time.now
+                          })
+  RECENT_SESSIONS.pop while RECENT_SESSIONS.size > RECENT_SESSIONS_MAX
+end
+
+def recently_completed?(card_key, window: 120)
+  ACTIVE_SESSIONS_MUTEX.synchronize do
+    RECENT_SESSIONS.any? do |s|
+      s[:card_key] == card_key && (Time.now - s[:finished_at]) < window
+    end
+  end
+end
+
+def session_active?(card_key)
+  ACTIVE_SESSIONS_MUTEX.synchronize do
+    info = ACTIVE_SESSIONS[card_key]
+    return false unless info
+
+    begin
+      Process.kill(0, info[:pid])
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      archive_session(card_key, info)
+      ACTIVE_SESSIONS.delete(card_key)
+      false
+    end
+  end
+end
+
+SESSION_WAIT_INTERVAL = 15
+SESSION_WAIT_MAX      = 600
+
+def wait_for_session?(card_key)
+  return true unless session_active?(card_key)
+
+  LOG.info "Waiting for active session on #{card_key} to finish..."
+  elapsed = 0
+  while session_active?(card_key) && elapsed < SESSION_WAIT_MAX
+    sleep SESSION_WAIT_INTERVAL
+    elapsed += SESSION_WAIT_INTERVAL
+    LOG.info "Still waiting on #{card_key} (#{elapsed}s elapsed)"
+  end
+
+  if session_active?(card_key)
+    LOG.warn "Timed out waiting for session on #{card_key} after #{SESSION_WAIT_MAX}s"
+    false
+  else
+    LOG.info "Session on #{card_key} finished after ~#{elapsed}s, proceeding"
+    true
+  end
+end
+
+# Recursively collect all descendant processes of a given PID via /proc.
+# Returns array of hashes: { pid:, ppid:, cmd:, elapsed_seconds: }
+def child_processes_for(pid)
+  children_map = build_proc_children_map
+  descendants = []
+  queue = [pid]
+
+  while (current = queue.shift)
+    (children_map[current] || []).each do |child_pid|
+      queue << child_pid
+      cmdline = read_proc_cmdline(child_pid)
+      elapsed = read_proc_elapsed(child_pid)
+      descendants << { pid: child_pid, ppid: current, cmd: cmdline, elapsed_seconds: elapsed }
+    end
+  end
+  descendants
+rescue StandardError => e
+  LOG.warn "Failed to enumerate child processes for PID #{pid}: #{e.message}"
+  []
+end
+
+# Build a ppid→children map from /proc in one pass.
+def build_proc_children_map
+  children_map = Hash.new { |h, k| h[k] = [] }
+  Dir.glob("/proc/[0-9]*/stat").each do |stat_path|
+    content = begin
+      File.read(stat_path)
+    rescue StandardError
+      next
+    end
+    close_paren = content.rindex(")")
+    next unless close_paren
+
+    prefix_pid = content[0...content.index("(")].strip.to_i
+    fields_after = content[(close_paren + 2)..].split
+    ppid = fields_after[1].to_i
+    children_map[ppid] << prefix_pid
+  end
+  children_map
+end
+
+# Read command line for a given PID from /proc.
+def read_proc_cmdline(pid)
+  File.read("/proc/#{pid}/cmdline").tr("\0", " ").strip
+rescue StandardError
+  "(unknown)"
+end
+
+# Calculate elapsed seconds since process start from /proc/stat.
+def read_proc_elapsed(pid)
+  stat_content = File.read("/proc/#{pid}/stat")
+rescue StandardError
+  0
+else
+  cp = stat_content.rindex(")")
+  starttime_ticks = begin
+    stat_content[(cp + 2)..].split[19].to_i
+  rescue StandardError
+    0
+  end
+  clk_tck = 100
+  uptime = begin
+    File.read("/proc/uptime").split[0].to_f
+  rescue StandardError
+    0
+  end
+  start_seconds = starttime_ticks.to_f / clk_tck
+  (uptime - start_seconds).to_i.clamp(0, Float::INFINITY).to_i
+end
+
+def register_session(card_key, pid, log_file: nil, message_id: nil, channel_id: nil, supersede_key: nil, draft_files: nil, agent_name: nil)
+  ACTIVE_SESSIONS_MUTEX.synchronize do
+    ACTIVE_SESSIONS[card_key] = {
+      pid: pid, started_at: Time.now, log_file: log_file,
+      message_id: message_id, channel_id: channel_id, supersede_key: supersede_key,
+      draft_files: draft_files, agent_name: agent_name
+    }
+  end
+end
+
+# --- Session supersede (Discord follow-up within window kills previous run) ---
+
+SUPERSEDE_WINDOW = 60 # seconds
+
+# Find an active session for the same supersede key (agent+channel) started within the window.
+# Returns the session info hash (with :session_key added) or nil.
+def find_supersedable_session(supersede_key)
+  ACTIVE_SESSIONS_MUTEX.synchronize do
+    ACTIVE_SESSIONS.each do |key, info|
+      next unless info[:supersede_key] == supersede_key
+      next if (Time.now - info[:started_at]) > SUPERSEDE_WINDOW
+
+      begin
+        Process.kill(0, info[:pid])
+        return info.merge(session_key: key)
+      rescue Errno::ESRCH, Errno::EPERM
+        next
+      end
+    end
+  end
+  nil
+end
+
+# Kill a session's process. Returns true if killed.
+def kill_session(session_key)
+  ACTIVE_SESSIONS_MUTEX.synchronize do
+    info = ACTIVE_SESSIONS[session_key]
+    return false unless info
+
+    # Kill child processes first (bottom-up), then the parent
+    children = child_processes_for(info[:pid])
+    children.reverse_each do |child|
+      Process.kill("KILL", child[:pid])
+    rescue StandardError
+      nil
+    end
+    begin
+      Process.kill("KILL", info[:pid])
+    rescue Errno::ESRCH, Errno::EPERM
+      # already gone
+    end
+    archive_session(session_key, info)
+    ACTIVE_SESSIONS.delete(session_key)
+    true
+  end
+end
+
+# --- Comment cooldown ---
+
+COMMENT_COOLDOWN = 60
+LAST_COMMENT_TIMES = {}
+
+def on_comment_cooldown?(card_key)
+  last = LAST_COMMENT_TIMES[card_key]
+  last && (Time.now - last) < COMMENT_COOLDOWN
+end
+
+def touch_comment_cooldown(card_key)
+  LAST_COMMENT_TIMES[card_key] = Time.now
+end
+
+# --- Deploy cooldown (debounce rapid PR pushes) ---
+
+DEPLOY_COOLDOWN = 30
+LAST_DEPLOY_TIMES = {}
+
+def on_deploy_cooldown?(env_key)
+  last = LAST_DEPLOY_TIMES[env_key]
+  last && (Time.now - last) < DEPLOY_COOLDOWN
+end
+
+def touch_deploy_cooldown(env_key)
+  LAST_DEPLOY_TIMES[env_key] = Time.now
+end
+
+# --- Agent dispatch depth (loop prevention) ---
+
+AGENT_DISPATCH_DEPTH = {}
+AGENT_DISPATCH_MAX_DEPTH = 10
+AGENT_DISPATCH_WINDOW = 3600
+
+def record_human_comment(card_internal_id)
+  AGENT_DISPATCH_DEPTH[card_internal_id] = { count: 0, last_human_at: Time.now }
+end
+
+def agent_dispatch_allowed?(card_internal_id)
+  info = AGENT_DISPATCH_DEPTH[card_internal_id]
+  return false unless info
+  return false if (Time.now - info[:last_human_at]) > AGENT_DISPATCH_WINDOW
+
+  info[:count] < AGENT_DISPATCH_MAX_DEPTH
+end
+
+def record_agent_dispatch(card_internal_id)
+  info = AGENT_DISPATCH_DEPTH[card_internal_id]
+  if info
+    info[:count] += 1
+  else
+    AGENT_DISPATCH_DEPTH[card_internal_id] = { count: 1, last_human_at: Time.now }
+  end
+end

data/lib/zillacore/skills.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+# Auto-skills: procedural skill extraction, progressive loading, usage tracking, and curation.
+#
+# Skills are SKILL.md files with YAML frontmatter stored in brain/knowledge/skills/.
+# They are auto-extracted after complex sessions and curated over time.
+
+require "yaml"
+require "json"
+require "time"
+
+SKILLS_DIR = File.join(KNOWLEDGE_DIR, "skills")
+FileUtils.mkdir_p(SKILLS_DIR)
+
+# --- SKILL.md format ---
+# ---
+# name: skill-name-slug
+# description: When to use this skill (one line)
+# tags: [ruby, testing, deployment]
+# ---
+# Procedural content...
+
+# --- Skill detection ---
+
+# Analyze an agent session log to determine if a skill should be extracted.
+# Triggers when: 5+ tool calls AND at least one error-recovery pattern detected.
+# Returns: { extract: true, topic: '...', summary: '...' } or { extract: false }
+def detect_skill_candidate(log_file)
+  return { extract: false } unless File.exist?(log_file)
+
+  content = File.read(log_file, encoding: "utf-8", invalid: :replace)
+
+  # Count tool invocations (kiro-cli logs tool calls as "Tool:" or "antml:invoke")
+  tool_calls = content.scan(/(?:^Tool:|<invoke|execute_bash|fs_write|fs_read|code.*operation)/).size
+  return { extract: false } if tool_calls < 5
+
+  # Detect error-recovery patterns: retry, fix, error followed by success
+  error_patterns = content.scan(/(?:error|failed|fix|retry|correcting|let me try)/i).size
+  recovery_patterns = content.scan(/(?:that worked|fixed|resolved|now passing|success)/i).size
+  has_recovery = error_patterns >= 1 && recovery_patterns >= 1
+
+  return { extract: false } unless has_recovery
+
+  { extract: true, tool_calls: tool_calls, error_patterns: error_patterns }
+end
+
+# --- Skill index (lightweight manifest for prompt injection) ---
+
+# Build a compact skill index for prompt injection.
+# Returns array of { name:, description:, path: } from all SKILL.md files.
+def build_skill_index
+  skills = []
+  Dir.glob(File.join(SKILLS_DIR, "**", "SKILL.md")).each do |path|
+    frontmatter = parse_skill_frontmatter(path)
+    next unless frontmatter
+
+    skills << {
+      name: frontmatter["name"],
+      description: frontmatter["description"],
+      tags: frontmatter["tags"] || [],
+      path: path
+    }
+  end
+  skills
+end
+
+# Parse YAML frontmatter from a SKILL.md file.
+def parse_skill_frontmatter(path)
+  content = File.read(path)
+  return nil unless content.start_with?("---")
+
+  parts = content.split("---", 3)
+  return nil if parts.size < 3
+
+  YAML.safe_load(parts[1])
+rescue StandardError => e
+  LOG.warn "[Skills] Failed to parse frontmatter in #{path}: #{e.message}"
+  nil
+end
+
+# --- Progressive skill loading ---
+
+# Maximum tokens (approx chars / 4) to spend on auto-injected skill content.
+SKILL_AUTO_INJECT_MAX_CHARS = 8000
+
+# Build the skill index section for prompt injection.
+# Only includes name + description (not full content) to keep tokens bounded.
+def skill_index_for_prompt
+  skills = build_skill_index
+  return "" if skills.empty?
+
+  lines = skills.map { |s| "- **#{s[:name]}**: #{s[:description]}" }
+  <<~SECTION
+    ## Available Skills
+    The following procedural skills are available. To use one, read the full file at its path.
+    #{lines.join("\n")}
+  SECTION
+end
+
+# Semantically match skills against the current task context and auto-inject their full content.
+# This is the skill:// equivalent — skills are loaded automatically when relevant, not manually.
+# Returns a prompt section with full skill content for top matches, plus an index of remaining skills.
+def auto_inject_skills(search_context)
+  skills = build_skill_index
+  return "" if skills.empty?
+  return "" unless system("which qmd > /dev/null 2>&1")
+
+  # Semantic search against skill descriptions to find relevant ones
+  matched_paths = match_skills_semantically(search_context, skills)
+
+  # Split into auto-injected (matched) and index-only (rest)
+  injected = []
+  chars_used = 0
+
+  matched_paths.each do |path|
+    content = File.read(path)
+    break if chars_used + content.size > SKILL_AUTO_INJECT_MAX_CHARS
+
+    skill = skills.find { |s| s[:path] == path }
+    next unless skill
+
+    injected << { name: skill[:name], description: skill[:description], content: content, path: path }
+    chars_used += content.size
+  end
+
+  remaining = skills.reject { |s| injected.any? { |i| i[:path] == s[:path] } }
+
+  sections = []
+
+  unless injected.empty?
+    sections << "## Auto-Loaded Skills (matched to your current task)"
+    sections << "These skills were automatically loaded because they're relevant to what you're working on.\n"
+    injected.each do |skill|
+      sections << "### Skill: #{skill[:name]}"
+      sections << skill[:content]
+      sections << ""
+      record_skill_usage(skill[:path], type: :use)
+    end
+  end
+
+  unless remaining.empty?
+    sections << "## Other Available Skills"
+    sections << "Additional skills not auto-loaded. Read the file if needed.\n"
+    remaining.each { |s| sections << "- **#{s[:name]}**: #{s[:description]} (`#{s[:path]}`)" }
+    sections << ""
+  end
+
+  sections.join("\n")
+end
+
+# Use qmd semantic search to find skills whose descriptions match the current context.
+# Returns an ordered array of SKILL.md paths (most relevant first).
+def match_skills_semantically(search_context, skills)
+  return [] if search_context.strip.empty?
+
+  # Search the knowledge collection — skills are indexed there since they're in knowledge/skills/
+  output, status = Open3.capture2("qmd", "search", search_context, "-c", KNOWLEDGE_COLLECTION, "-n", "10", "--md")
+  return [] unless status.success? && !output.strip.empty?
+
+  # Extract paths from qmd results that point to SKILL.md files
+  skill_paths = skills.map { |s| s[:path] }
+  matched = []
+
+  # qmd --md output includes file paths in results — match against known skill paths
+  skill_paths.each do |path|
+    # Check if the skill's directory name or file appears in search results
+    skill_dir_name = File.basename(File.dirname(path))
+    matched << path if output.include?(skill_dir_name) || output.include?(path)
+  end
+
+  matched
+rescue StandardError => e
+  LOG.warn "[Skills] Semantic matching failed: #{e.message}"
+  []
+end
+
+# --- Usage tracking ---
+
+SKILL_USAGE_SUFFIX = ".usage.json"
+
+def skill_usage_path(skill_path)
+  skill_path.sub(/SKILL\.md$/, "SKILL.usage.json")
+end
+
+# Record a view (skill index shown in prompt) or use (agent read the full skill).
+def record_skill_usage(skill_path, type: :view)
+  usage_file = skill_usage_path(skill_path)
+  data = if File.exist?(usage_file)
+           JSON.parse(File.read(usage_file))
+         else
+           { "views" => 0, "uses" => 0, "last_viewed" => nil, "last_used" => nil, "created_at" => Time.now.iso8601 }
+         end
+
+  now = Time.now.iso8601
+  case type
+  when :view
+    data["views"] = (data["views"] || 0) + 1
+    data["last_viewed"] = now
+  when :use
+    data["uses"] = (data["uses"] || 0) + 1
+    data["last_used"] = now
+  end
+
+  File.write(usage_file, JSON.pretty_generate(data))
+rescue StandardError => e
+  LOG.warn "[Skills] Failed to record usage for #{skill_path}: #{e.message}"
+end
+
+# Batch-record views for all skills in the index (called when prompt is built).
+def record_skill_index_views
+  build_skill_index.each { |s| record_skill_usage(s[:path], type: :view) }
+end
+
+# --- Curator ---
+
+SKILL_STALE_DAYS = 90 # Archive skills unused for this many days
+SKILL_ARCHIVE_DIR = File.join(SKILLS_DIR, "_archived")
+
+# Run the curator: archive stale skills, log consolidation candidates.
+# Never auto-deletes — only moves to _archived/.
+def curate_skills
+  FileUtils.mkdir_p(SKILL_ARCHIVE_DIR)
+  now = Time.now
+  archived = 0
+  consolidation_candidates = []
+
+  skills = build_skill_index
+  skills_by_tag = Hash.new { |h, k| h[k] = [] }
+
+  skills.each do |skill|
+    usage_file = skill_usage_path(skill[:path])
+    usage = if File.exist?(usage_file)
+              JSON.parse(File.read(usage_file))
+            else
+              { "views" => 0, "uses" => 0, "last_viewed" => nil, "last_used" => nil }
+            end
+
+    # Check staleness
+    last_activity = [usage["last_viewed"], usage["last_used"]].compact.max
+    if last_activity.nil? || (now - Time.parse(last_activity)) > (SKILL_STALE_DAYS * 86_400)
+      archive_skill(skill[:path])
+      archived += 1
+      next
+    end
+
+    # Track tags for consolidation detection
+    (skill[:tags] || []).each { |tag| skills_by_tag[tag] << skill }
+  end
+
+  # Detect consolidation candidates: 3+ skills sharing the same tag
+  skills_by_tag.each do |tag, tag_skills|
+    consolidation_candidates << { tag: tag, skills: tag_skills.map { |s| s[:name] } } if tag_skills.size >= 3
+  end
+
+  LOG.info "[Curator] Archived #{archived} stale skill(s)" if archived.positive?
+  LOG.info "[Curator] Consolidation candidates: #{consolidation_candidates.map { |c| c[:tag] }.join(", ")}" unless consolidation_candidates.empty?
+
+  { archived: archived, consolidation_candidates: consolidation_candidates }
+rescue StandardError => e
+  LOG.warn "[Curator] Error during curation: #{e.message}"
+  { archived: 0, consolidation_candidates: [], error: e.message }
+end
+
+def archive_skill(skill_path)
+  skill_dir = File.dirname(skill_path)
+  skill_name = File.basename(skill_dir)
+  archive_dest = File.join(SKILL_ARCHIVE_DIR, skill_name)
+
+  FileUtils.mkdir_p(archive_dest)
+  FileUtils.mv(Dir.glob(File.join(skill_dir, "*")), archive_dest)
+  FileUtils.rmdir(skill_dir) if Dir.empty?(skill_dir)
+
+  LOG.info "[Curator] Archived skill: #{skill_name}"
+rescue StandardError => e
+  LOG.warn "[Curator] Failed to archive #{skill_path}: #{e.message}"
+end

data/lib/zillacore/users.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# User identity registry - resolves identities across platforms
+# (Discord, GitHub, Fizzy)
+
+USERS_FILE = File.join(ZILLACORE_DIR, "users.json")
+
+def load_user_registry
+  return { "users" => [] } unless File.exist?(USERS_FILE)
+
+  data = JSON.parse(File.read(USERS_FILE))
+  LOG.info "Loaded #{data["users"].size} user(s) from #{USERS_FILE}"
+  data
+rescue JSON::ParserError => e
+  LOG.error "Failed to parse user registry: #{e.message}"
+  { "users" => [] }
+end
+
+def reload_user_registry!(force: false)
+  return unless file_changed?(USERS_FILE, force: force)
+
+  USER_REGISTRY.replace(load_user_registry)
+  LOG.info "Reloaded user registry: #{USER_REGISTRY["users"].size} users"
+end
+
+USER_REGISTRY = load_user_registry
+
+# Find user by Discord user ID
+def find_user_by_discord_id(user_id)
+  USER_REGISTRY["users"].find { |u| u.dig("identities", "discord", "user_id") == user_id.to_s }
+end
+
+# Find user by Discord username
+def find_user_by_discord_username(username)
+  USER_REGISTRY["users"].find { |u| u.dig("identities", "discord", "username") == username.to_s }
+end
+
+# Find user by GitHub username
+def find_user_by_github_username(username)
+  USER_REGISTRY["users"].find { |u| u.dig("identities", "github", "username") == username.to_s }
+end
+
+# Find user by Fizzy username
+def find_user_by_fizzy_username(username)
+  USER_REGISTRY["users"].find { |u| u.dig("identities", "fizzy", "username") == username.to_s }
+end
+
+# Find user by canonical name
+def find_user_by_canonical_name(name)
+  USER_REGISTRY["users"].find { |u| u["canonical_name"].downcase == name.downcase }
+end
+
+# Find user by any identifier (tries all platforms)
+def find_user(identifier)
+  find_user_by_discord_id(identifier) ||
+    find_user_by_discord_username(identifier) ||
+    find_user_by_github_username(identifier) ||
+    find_user_by_fizzy_username(identifier) ||
+    find_user_by_canonical_name(identifier)
+end
+
+# Get canonical name for a platform-specific identifier
+def canonical_name_for(identifier)
+  user = find_user(identifier)
+  user ? user["canonical_name"] : identifier
+end
+
+# Get all human users (exclude AI agents)
+def human_users
+  USER_REGISTRY["users"].reject { |u| u["notes"]&.include?("AI agent") }
+end
+
+# Get all AI agents
+def ai_agents
+  USER_REGISTRY["users"].select { |u| u["notes"]&.include?("AI agent") }
+end

data/lib/zillacore/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ZillaCore
+  # @return [String] the current gem version
+  VERSION = "0.0.1"
+end