dkit 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 53e0c6ec379900435c8ecf139f2960b5438df945e674a6709be32a71732fd9e9
+  data.tar.gz: f2b8ad870c59fc01acba6640e6c02cb13216a303373cfb7e008a2dd3d1e4d7fd
+SHA512:
+  metadata.gz: 788dcd77ebde166204346894dacc6772fbd04fe613acef1a6b72f16fff26f7894a238948d3d26c59377a942c9b28081d28a9b03b366b59a8cddf0372df1dd536
+  data.tar.gz: 1d19f03a3b15edf459ad0d20806ed4abce82983b3db85fedd98be820f1b6a9b96a6ee351fc4294908b8cdec56ab496a432bb1eb8bf1a67bb665af86a2fe639e7

data/bin/dkit

@@ -0,0 +1,485 @@
+#!/usr/bin/env ruby
+# dkit — DevKit CLI: routes shell commands into a running devcontainer
+#
+# Install:
+#   gem install dkit
+#   echo 'eval "$(dkit hook)"' >> ~/.zshrc && exec zsh
+#
+# Install from source:
+#   gem build dkit.gemspec && gem install dkit-*.gem
+#
+# Usage: dkit help
+
+require 'json'
+require 'yaml'
+require 'pathname'
+require 'shellwords'
+require 'fileutils'
+
+VERSION   = "0.2.0"
+DC_CONFIG = ".devcontainer/devcontainer.json"
+DC_INTERCEPT = ".devcontainer/dkit-intercept"
+
+SPECIAL_COMMANDS = %w[code claude].freeze
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+def abort_err(msg)
+  warn "dkit: #{msg}"
+  exit 1
+end
+
+def docker(*args, capture: false)
+  cmd = ["docker", *args]
+  if capture
+    out = `#{cmd.map(&:shellescape).join(" ")} 2>/dev/null`.strip
+    out.empty? ? nil : out
+  else
+    system(*cmd)
+  end
+end
+
+# ── Project root (lightweight — no docker) ─────────────────────────────────────
+
+def find_project_root(from: Dir.pwd)
+  if (cached = ENV["DKIT_PROJECT_ROOT"]) && !cached.empty? &&
+     File.exist?(File.join(cached, DC_CONFIG))
+    return cached
+  end
+
+  path = Pathname.new(from)
+  loop do
+    return path.to_s if (path + DC_CONFIG).exist?
+    parent = path.parent
+    return nil if parent == path
+    path = parent
+  end
+end
+
+# ── Per-project intercept file ─────────────────────────────────────────────────
+
+def intercept_file(project_root)
+  File.join(project_root, DC_INTERCEPT)
+end
+
+def intercept_list(project_root)
+  f = intercept_file(project_root)
+  return [] unless File.exist?(f)
+  File.readlines(f, chomp: true)
+      .reject { |l| l.strip.empty? || l.strip.start_with?("#") }
+      .map(&:strip)
+      .uniq
+end
+
+def intercept_add(project_root, cmd)
+  list = intercept_list(project_root)
+  if list.include?(cmd)
+    puts "dkit: '#{cmd}' is already in the intercept list"
+    return
+  end
+  File.open(intercept_file(project_root), "a") { |f| f.puts cmd }
+  puts "dkit: added '#{cmd}' — reload shell to activate (exec zsh)"
+end
+
+def intercept_remove(project_root, cmd)
+  f = intercept_file(project_root)
+  unless intercept_list(project_root).include?(cmd)
+    puts "dkit: '#{cmd}' is not in the intercept list"
+    return
+  end
+  lines = File.readlines(f).reject { |l| l.strip == cmd }
+  File.write(f, lines.join)
+  puts "dkit: removed '#{cmd}' — reload shell to deactivate (exec zsh)"
+end
+
+# ── Devcontainer config ────────────────────────────────────────────────────────
+
+def load_dc_config(project_root)
+  raw = File.read(File.join(project_root, DC_CONFIG))
+  raw = raw.gsub(%r{/\*.*?\*/}m, "").gsub(%r{//[^\n]*}, "")
+  JSON.parse(raw)
+end
+
+def resolve_container_name(project_root, cfg)
+  service       = cfg["service"]
+  compose_files = Array(cfg["dockerComposeFile"]).map do |f|
+    File.expand_path(f, File.join(project_root, ".devcontainer"))
+  end
+
+  # Strategy A: container_name from compose YAML
+  compose_files.each do |cf|
+    next unless File.exist?(cf)
+    data = YAML.safe_load(File.read(cf))
+    name = data.dig("services", service, "container_name")
+    return name if name
+  end
+
+  # Strategy B: docker label query
+  project_name = File.basename(project_root).downcase.gsub(/[^a-z0-9]/, "")
+  name = docker("ps",
+    "--filter", "label=com.docker.compose.service=#{service}",
+    "--filter", "label=com.docker.compose.project=#{project_name}",
+    "--format", "{{.Names}}",
+    capture: true
+  )
+  return name if name
+
+  # Strategy C: docker compose ps -q
+  first_file = compose_files.first
+  if first_file && File.exist?(first_file)
+    id = docker("compose", "-f", first_file, "ps", "-q", service, capture: true)
+    return id if id
+  end
+
+  nil
+end
+
+def container_running?(name)
+  status = docker("inspect", "--format", "{{.State.Status}}", name, capture: true)
+  status == "running"
+end
+
+def container_cwd(project_root, workspace)
+  rel = Pathname.new(Dir.pwd).relative_path_from(Pathname.new(project_root)).to_s
+  rel.start_with?("..") ? workspace : File.join(workspace, rel)
+rescue ArgumentError
+  workspace
+end
+
+# ── Context ────────────────────────────────────────────────────────────────────
+
+Context = Struct.new(:project_root, :container, :user, :workspace, :cwd, :compose_files, keyword_init: true)
+
+def resolve!(quiet: false)
+  root = find_project_root
+  unless root
+    quiet ? exit(1) : abort_err("no #{DC_CONFIG} found in #{Dir.pwd} or any parent directory")
+  end
+
+  cfg       = load_dc_config(root)
+  service   = cfg["service"]          || "app"
+  workspace = cfg["workspaceFolder"]  || "/workspace"
+  user      = cfg["remoteUser"]       || "root"
+
+  container = resolve_container_name(root, cfg)
+  unless container
+    quiet ? exit(1) : abort_err("could not determine container name for service '#{service}'")
+  end
+
+  unless container_running?(container)
+    quiet ? exit(1) : abort_err("container '#{container}' is not running. Try: dkit up")
+  end
+
+  compose_files = Array(cfg["dockerComposeFile"]).map do |f|
+    File.expand_path(f, File.join(root, ".devcontainer"))
+  end
+
+  Context.new(
+    project_root:  root,
+    container:     container,
+    user:          user,
+    workspace:     workspace,
+    cwd:           container_cwd(root, workspace),
+    compose_files: compose_files
+  )
+end
+
+# ── Subcommands ────────────────────────────────────────────────────────────────
+
+def cmd_root
+  root = find_project_root
+  root ? puts(root) : exit(1)
+end
+
+def cmd_init
+  root = find_project_root
+  abort_err("no #{DC_CONFIG} found — are you inside a devcontainer project?") unless root
+
+  f = intercept_file(root)
+  if File.exist?(f)
+    puts "dkit: #{f} already exists:"
+    puts File.read(f)
+    return
+  end
+
+  cmds = []
+  cmds += %w[rails bundle rspec rubocop rake] if File.exist?(File.join(root, "Gemfile"))
+  cmds += %w[yarn node npx]                   if File.exist?(File.join(root, "package.json"))
+  cmds = %w[bash]                             if cmds.empty?
+
+  File.write(f, cmds.join("\n") + "\n")
+  puts "dkit: created #{f}"
+  puts "Commands: #{cmds.join(", ")}"
+  puts "Tip: commit this file to share with your team"
+  puts "     git add #{DC_INTERCEPT} && git commit -m 'chore: add dkit intercept config'"
+end
+
+def cmd_hook
+  puts <<~'ZSH'
+    # Generated by: dkit hook
+    # Add to ~/.zshrc: eval "$(dkit hook)"
+
+    _DKIT_ROOT=""
+    _DKIT_ACTIVE_CMDS=()
+
+    _dkit_reset() {
+      local cmd
+      for cmd in "${_DKIT_ACTIVE_CMDS[@]}"; do
+        unfunction "$cmd" 2>/dev/null
+      done
+      _DKIT_ACTIVE_CMDS=()
+    }
+
+    _dkit_load() {
+      local root="$1"
+      local intercept="$root/.devcontainer/dkit-intercept"
+      [[ -f "$intercept" ]] || return
+      local cmd
+      while IFS= read -r cmd; do
+        [[ -z "$cmd" || "${cmd[1]}" == "#" ]] && continue
+        # Trim whitespace
+        cmd="${cmd## }"
+        cmd="${cmd%% }"
+        [[ -z "$cmd" ]] && continue
+        eval "function ${cmd}() {
+          if dkit status --quiet 2>/dev/null; then
+            dkit run ${cmd} \"\$@\"
+          else
+            command ${cmd} \"\$@\"
+          fi
+        }"
+        _DKIT_ACTIVE_CMDS+=("${cmd}")
+      done < "$intercept"
+    }
+
+    _dkit_chpwd() {
+      # Fast path: still inside the same project root
+      if [[ -n "$_DKIT_ROOT" && "$PWD" == "$_DKIT_ROOT"* ]]; then
+        return
+      fi
+      local new_root
+      new_root="$(dkit root 2>/dev/null || echo '')"
+      [[ "$new_root" == "$_DKIT_ROOT" ]] && return
+      _dkit_reset
+      _DKIT_ROOT="$new_root"
+      [[ -n "$new_root" ]] && _dkit_load "$new_root"
+    }
+
+    # Special commands — always available, always route to devcontainer
+    code() {
+      if dkit status --quiet 2>/dev/null; then
+        dkit code "$@"
+      else
+        command code "$@"
+      fi
+    }
+
+    claude() {
+      if dkit status --quiet 2>/dev/null; then
+        dkit claude "$@"
+      else
+        command claude "$@"
+      fi
+    }
+
+    autoload -U add-zsh-hook
+    add-zsh-hook chpwd _dkit_chpwd
+    _dkit_chpwd
+  ZSH
+end
+
+def cmd_exec(ctx, args)
+  abort_err("exec: no command given") if args.empty?
+  system("docker", "exec", "--user", ctx.user, "--workdir", ctx.cwd, ctx.container, *args)
+  exit $?.exitstatus
+end
+
+def cmd_run(ctx, args)
+  abort_err("run: no command given") if args.empty?
+  exec("docker", "exec", "-it", "--user", ctx.user, "--workdir", ctx.cwd, ctx.container, *args)
+end
+
+def cmd_shell(ctx)
+  exec("docker", "exec", "-it", "--user", ctx.user, "--workdir", ctx.cwd, ctx.container, "zsh", "-l")
+end
+
+def cmd_claude(ctx, args)
+  exec("docker", "exec", "-it", "--user", ctx.user, "--workdir", ctx.cwd, ctx.container, "claude", *args)
+end
+
+def cmd_code(ctx, path_arg)
+  host_path = path_arg ? File.expand_path(path_arg) : ctx.project_root
+  rel = begin
+    Pathname(host_path).relative_path_from(Pathname(ctx.project_root)).to_s
+  rescue ArgumentError
+    "."
+  end
+  container_path = (rel == ".") ? ctx.workspace : File.join(ctx.workspace, rel)
+
+  payload = JSON.generate({ "hostPath" => ctx.project_root })
+  hex     = payload.unpack1("H*")
+  uri     = "vscode-remote://dev-container+#{hex}#{container_path}"
+
+  if system("which code > /dev/null 2>&1")
+    exec("code", "--folder-uri", uri)
+  elsif system("which devcontainer > /dev/null 2>&1")
+    exec("devcontainer", "open", ctx.project_root)
+  else
+    abort_err("'code' CLI not found. In VS Code: Shell Command: Install 'code' command in PATH")
+  end
+end
+
+def cmd_status(ctx, quiet:)
+  return if quiet
+  puts "Project root  : #{ctx.project_root}"
+  puts "Container     : #{ctx.container} (running)"
+  puts "Remote user   : #{ctx.user}"
+  puts "Workspace     : #{ctx.workspace}"
+  puts "Exec CWD      : #{ctx.cwd}"
+  puts "Compose files : #{ctx.compose_files.join(", ")}"
+  f = intercept_file(ctx.project_root)
+  if File.exist?(f)
+    puts "Intercept     : #{intercept_list(ctx.project_root).join(", ")}"
+  else
+    puts "Intercept     : (none — run 'dkit init')"
+  end
+end
+
+def cmd_compose(ctx, args)
+  files_flags = ctx.compose_files.flat_map { |f| ["-f", f] }
+  exec("docker", "compose", *files_flags, *args)
+end
+
+def cmd_help
+  puts <<~HELP
+    dkit #{VERSION} — DevKit: routes commands into your devcontainer
+
+    Usage:
+      dkit exec <cmd> [args]          Run command without TTY (scripting)
+      dkit run  <cmd> [args]          Run command interactively (TTY)
+      dkit shell                      Open interactive shell (zsh) in container
+      dkit code  [path]               Open VS Code attached to devcontainer
+      dkit claude [args]              Run claude in container (interactive)
+
+      dkit status                     Show resolved devcontainer context
+      dkit status --quiet             Exit 0 if container running, 1 otherwise
+      dkit root                       Print project root (no docker needed)
+
+      dkit up    [service]            docker compose up -d
+      dkit down  [flags]              docker compose down
+      dkit logs  [service]            docker compose logs -f
+
+      dkit init                       Create .devcontainer/dkit-intercept with auto-detected defaults
+      dkit intercept list             List intercepted commands for current project
+      dkit intercept add <cmd>        Add command to current project's intercept list
+      dkit intercept remove <cmd>     Remove command from current project's intercept list
+
+      dkit hook                       Emit shell hook code for ~/.zshrc
+      dkit version                    Print version
+      dkit help                       Show this help
+
+    Shell integration (add to ~/.zshrc):
+      eval "$(dkit hook)"
+
+    Project setup:
+      cd ~/projects/my-app
+      dkit init                       # creates .devcontainer/dkit-intercept
+      git add .devcontainer/dkit-intercept && git commit -m "chore: add dkit config"
+
+    Adding a new command to a project:
+      dkit intercept add terraform
+      exec zsh
+  HELP
+end
+
+# ── Entry point ────────────────────────────────────────────────────────────────
+
+command = ARGV.shift&.downcase
+
+case command
+when "hook"
+  cmd_hook
+
+when "root"
+  cmd_root
+
+when "init"
+  cmd_init
+
+when "intercept"
+  root = find_project_root
+  abort_err("no #{DC_CONFIG} found — are you inside a devcontainer project?") unless root
+
+  sub = ARGV.shift&.downcase
+  case sub
+  when "list"
+    list = intercept_list(root)
+    f    = intercept_file(root)
+    if list.empty?
+      puts "No intercept file found. Run: dkit init"
+    else
+      puts "Intercepted commands (#{f}):"
+      list.each { |c| puts "  #{c}" }
+    end
+    puts "\nSpecial (always active): #{SPECIAL_COMMANDS.join(", ")}"
+  when "add"
+    abort_err("intercept add: command name required") if ARGV.empty?
+    intercept_add(root, ARGV.first)
+  when "remove"
+    abort_err("intercept remove: command name required") if ARGV.empty?
+    intercept_remove(root, ARGV.first)
+  else
+    abort_err("intercept: unknown subcommand '#{sub}'. Use: list, add, remove")
+  end
+
+when "status"
+  quiet = ARGV.include?("--quiet")
+  ctx   = resolve!(quiet: quiet)
+  cmd_status(ctx, quiet: quiet)
+
+when "exec"
+  ctx = resolve!
+  cmd_exec(ctx, ARGV)
+
+when "run"
+  ctx = resolve!
+  cmd_run(ctx, ARGV)
+
+when "shell"
+  ctx = resolve!
+  cmd_shell(ctx)
+
+when "claude"
+  ctx = resolve!
+  cmd_claude(ctx, ARGV)
+
+when "code"
+  ctx = resolve!
+  cmd_code(ctx, ARGV.first)
+
+when "up"
+  ctx = resolve!(quiet: true) rescue nil
+  if ctx
+    cmd_compose(ctx, ["up", "-d", *ARGV])
+  else
+    exec("docker", "compose", "up", "-d", *ARGV)
+  end
+
+when "down"
+  ctx = resolve!
+  cmd_compose(ctx, ["down", *ARGV])
+
+when "logs"
+  ctx = resolve!
+  cmd_compose(ctx, ["logs", "-f", *ARGV])
+
+when "version", "--version", "-v"
+  puts "dkit #{VERSION}"
+
+when nil, "help", "--help", "-h"
+  cmd_help
+
+else
+  warn "dkit: unknown command '#{command}'. Run 'dkit help'."
+  exit 1
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: dkit
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Augusto Stroligo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-13 00:00:00.000000000 Z
+dependencies: []
+description: Routes shell commands transparently into a running devcontainer with
+  shell hook integration, per-project intercept lists, VS Code attachment, and docker
+  compose helpers.
+email:
+executables:
+- dkit
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/dkit
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: 'DevKit CLI: routes shell commands into a running devcontainer'
+test_files: []