right_now 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a566156485512651cffed05ab55379f0cab3b025fdc07f209341eea69dd53352
+  data.tar.gz: c7699767b0dd24e0e119ea29ccf0fa2f2d94669330e7f0c146fa7c02b6c0f1f2
+SHA512:
+  metadata.gz: a17606397b14a73843e9942a339646b8d2698e405a69c846f5ede2b0a92c523311d8b053a3b55e2dd6a60a560908dfcf70ea06bc0bb0d9b0b43757eada5e8b9a
+  data.tar.gz: 53e202722d68b59fa46088fcce2395dcda200a909135bae509dfc7af8886204dd1b3d0d00424cc0e877f8b0ed41f573a8c1bb6715e602a74e0dc395cab4d866e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SEAHAL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+# rightnow
+
+Rails-aware code resolver.
+
+## Installation
+
+```sh
+gem install right_now
+```
+
+## Quick Examples
+
+```sh
+rn user
+rn m user
+rn c admin/users
+rn helper abc def ghi
+rn app/controllers/application_controller.rb
+rn public robots
+rn user --print
+rn user --json
+```
+
+## What It Does
+`rn` resolves a short query to the most likely existing file in a Rails project.
+
+## Query Model
+`rn` supports three basic query styles:
+* path-like queries are strongest
+* kind-prefixed queries narrow the search scope
+* generic queries search across known Rails paths
+
+Slash-separated and space-separated forms are equivalent:
+```sh
+rn c admin users
+rn c admin/users
+```
+
+## Supported Kinds
+The command feel is intentionally close to Rails generator conventions.
+* `model` / `m`
+* `controller` / `c`
+* `helper` / `h`
+* `view` / `v`
+* `job` / `j`
+* `service`
+* `mailer`
+* `channel`
+* `public`
+
+## Output Modes
+```sh
+rn user --print
+rn user --json
+```
+`--print` prints the best path only.
+`--json` prints scored candidate data.
+
+## Search Scope
+`rn` only searches Rails-relevant paths such as:
+* `app/models`
+* `app/controllers`
+* `app/helpers`
+* `app/views`
+* `app/services`
+* `app/jobs`
+* `app/mailers`
+* `app/channels`
+* `public`
+
+It does not search log files, `tmp`, `vendor`, `node_modules`, or arbitrary file contents.
+
+## Philosophy
+* resolver, not search engine
+* Rails-aware
+* finite candidate set
+* predictable heuristics
+* generator-like ergonomics
+
+## Non-Goals
+* no grep-style full text search
+* no TUI yet
+* no LSP integration
+* no log viewer
+
+## Future
+Possible future work includes `rni`, better ranking, and optional indexing.

data/exe/rn

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "rightnow"
+
+exit RightNow::CLI.start(ARGV)

data/exe/rni

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "rightnow"
+
+warn "rni is not implemented yet."
+exit 1

data/lib/rightnow/cli.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+require "shellwords"
+
+module RightNow
+  class CLI
+    def self.start(argv = ARGV)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @query = Query.parse(argv)
+      @resolver = Resolver.new
+    end
+
+    def run
+      return handle_empty_query if query.empty?
+
+      results = resolver.resolve(query)
+
+      if query.json
+        puts JSON.pretty_generate(results)
+        return 0
+      end
+
+      if query.print
+        best = results.first
+        if best
+          puts best[:path]
+          return 0
+        end
+
+        return 1
+      end
+
+      return open_in_editor(results.first[:path]) ? 0 : 1 if results.any?
+
+      1
+    end
+
+    private
+
+    attr_reader :query, :resolver
+
+    def handle_empty_query
+      if query.json
+        puts JSON.pretty_generate([])
+        return 0
+      end
+
+      1
+    end
+
+    def open_in_editor(path)
+      command = Shellwords.split(editor_command)
+      return false if command.empty?
+
+      system(*command, File.join(resolver.root, path))
+    end
+
+    def editor_command
+      ENV["CR_EDITOR"] || ENV["VISUAL"] || ENV["EDITOR"] || "vim"
+    end
+  end
+end

data/lib/rightnow/query.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RightNow
+  class Query
+    KIND_ALIASES = {
+      "m" => "model",
+      "model" => "model",
+      "c" => "controller",
+      "controller" => "controller",
+      "h" => "helper",
+      "helper" => "helper",
+      "v" => "view",
+      "view" => "view",
+      "j" => "job",
+      "job" => "job",
+      "service" => "service",
+      "mailer" => "mailer",
+      "channel" => "channel",
+      "public" => "public"
+    }.freeze
+
+    attr_reader :print, :json, :kind, :terms, :path_mode, :original_tokens
+
+    def self.parse(argv)
+      options = { print: false, json: false }
+
+      parser = OptionParser.new do |opts|
+        opts.on("--print", "Print only the best path") { options[:print] = true }
+        opts.on("--json", "Print top candidates as JSON") { options[:json] = true }
+      end
+
+      original_tokens = parser.parse(argv.dup)
+      normalized_tokens = original_tokens.flat_map { |token| token.split("/") }.reject(&:empty?)
+      path_mode = original_tokens.any? { |token| token.include?("/") }
+
+      kind = nil
+      terms = normalized_tokens.dup
+
+      if (first = terms.first) && KIND_ALIASES.key?(first.downcase)
+        kind = KIND_ALIASES.fetch(first.downcase)
+        terms = terms.drop(1)
+      end
+
+      if !path_mode
+        terms = terms.select { |term| term.length >= 2 }
+      end
+
+      new(
+        print: options[:print],
+        json: options[:json],
+        kind: kind,
+        terms: terms,
+        path_mode: path_mode,
+        original_tokens: original_tokens
+      )
+    end
+
+    def initialize(print:, json:, kind:, terms:, path_mode:, original_tokens:)
+      @print = print
+      @json = json
+      @kind = kind
+      @terms = terms
+      @path_mode = path_mode
+      @original_tokens = original_tokens
+    end
+
+    def empty?
+      terms.empty? && kind.nil? && !path_mode
+    end
+
+    def query_path
+      @query_path ||= normalized_path(terms)
+    end
+
+    private
+
+    def normalized_path(parts)
+      parts.join("/").downcase
+    end
+  end
+end

data/lib/rightnow/resolver.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module RightNow
+  class Resolver
+    SEARCH_SCOPES = {
+      "model" => "app/models",
+      "controller" => "app/controllers",
+      "helper" => "app/helpers",
+      "view" => "app/views",
+      "job" => "app/jobs",
+      "service" => "app/services",
+      "mailer" => "app/mailers",
+      "channel" => "app/channels",
+      "public" => "public"
+    }.freeze
+
+    attr_reader :root
+
+    def initialize(root: detect_root)
+      @root = root
+    end
+
+    def resolve(query)
+      candidates = collect_candidates(query)
+      ranked = candidates.map { |path| score_candidate(path, query) }
+                        .sort_by { |candidate| [-candidate[:score], candidate[:path]] }
+      ranked.first(10)
+    end
+
+    def best_candidate(query)
+      resolve(query).first
+    end
+
+    def detect_root
+      current = Dir.pwd
+
+      loop do
+        return current if rails_project_root?(current)
+
+        parent = File.dirname(current)
+        return Dir.pwd if parent == current
+
+        current = parent
+      end
+    end
+
+    private
+
+    def collect_candidates(query)
+      scopes = query.kind ? [SEARCH_SCOPES.fetch(query.kind)] : SEARCH_SCOPES.values
+      scopes.flat_map { |scope| glob_scope(scope) }.uniq
+    end
+
+    def glob_scope(scope)
+      pattern = File.join(root, scope, "**", "*")
+      Dir.glob(pattern, File::FNM_DOTMATCH)
+         .select { |path| File.file?(path) }
+         .map { |path| relative_path(path) }
+         .reject { |path| excluded_path?(path) }
+    end
+
+    def excluded_path?(path)
+      path.split(File::SEPARATOR).any? do |segment|
+        %w[node_modules vendor tmp log .git].include?(segment)
+      end
+    end
+
+    def relative_path(path)
+      path.sub(%r{\A#{Regexp.escape(root)}/?}, "")
+    end
+
+    def score_candidate(path, query)
+      score = 0
+      downcased_path = path.downcase
+      terms = query.terms.map(&:downcase)
+      kind_scope = query.kind && path.start_with?(SEARCH_SCOPES.fetch(query.kind) + "/")
+
+      score += 200 if kind_scope
+      score += exact_path_score(path, query)
+      score += basename_score(path, query)
+      score += ordered_terms_score(downcased_path, terms)
+      score += unordered_terms_score(downcased_path, terms)
+      score += kind_hint_score(path, query)
+      score += path_mode_score(downcased_path, query)
+
+      { path:, score: }
+    end
+
+    def exact_path_score(path, query)
+      return 0 if query.query_path.empty?
+
+      downcased = path.downcase
+      if downcased == query.query_path
+        1_500
+      elsif downcased.end_with?(query.query_path)
+        1_000
+      elsif downcased.include?(query.query_path)
+        700
+      else
+        0
+      end
+    end
+
+    def basename_score(path, query)
+      return 0 if query.terms.empty?
+
+      basename = File.basename(path, File.extname(path)).downcase
+      expected = expected_basename(query)
+
+      if expected && basename == expected
+        500
+      elsif query.terms.map(&:downcase).include?(basename)
+        250
+      else
+        0
+      end
+    end
+
+    def ordered_terms_score(path, terms)
+      return 0 if terms.empty?
+      return 300 if subsequence?(terms, path_terms(path))
+
+      0
+    end
+
+    def unordered_terms_score(path, terms)
+      return 0 if terms.empty?
+      return 100 if terms.all? { |term| path.include?(term) }
+
+      0
+    end
+
+    def kind_hint_score(path, query)
+      return 0 unless query.kind
+
+      expected = expected_kind_path(query)
+      return 350 if expected && path.start_with?(expected)
+
+      0
+    end
+
+    def path_mode_score(path, query)
+      return 0 unless query.path_mode
+      return 500 if path.include?(query.query_path)
+
+      0
+    end
+
+    def expected_basename(query)
+      return nil if query.terms.empty?
+
+      case query.kind
+      when "model"
+        "#{singularize(query.terms.join("_"))}"
+      when "controller"
+        "#{pluralize(query.terms.last)}_controller"
+      when "helper"
+        "#{query.terms.last}_helper"
+      when "view"
+        query.terms.last
+      when "job"
+        "#{query.terms.join("_")}_job"
+      when "service"
+        "#{query.terms.join("_")}_service"
+      when "mailer"
+        "#{query.terms.join("_")}_mailer"
+      when "channel"
+        "#{query.terms.join("_")}_channel"
+      when "public"
+        query.terms.join("/")
+      end
+    end
+
+    def expected_kind_path(query)
+      return nil if query.terms.empty?
+
+      case query.kind
+      when "model"
+        File.join("app/models", "#{expected_basename(query)}.rb")
+      when "controller"
+        dir = query.terms.length > 1 ? query.terms[0..-2].join("/") : ""
+        base = "#{pluralize(query.terms.last)}_controller.rb"
+        dir.empty? ? File.join("app/controllers", base) : File.join("app/controllers", dir, base)
+      when "helper"
+        dir = query.terms.length > 1 ? query.terms[0..-2].join("/") : ""
+        base = "#{query.terms.last}_helper.rb"
+        dir.empty? ? File.join("app/helpers", base) : File.join("app/helpers", dir, base)
+      when "view"
+        dir = query.terms.length > 1 ? query.terms[0..-2].join("/") : ""
+        base = query.terms.last
+        dir.empty? ? File.join("app/views", base) : File.join("app/views", dir, base)
+      when "job"
+        File.join("app/jobs", "#{query.terms.join("_")}_job.rb")
+      when "service"
+        File.join("app/services", "#{query.terms.join("_")}_service.rb")
+      when "mailer"
+        File.join("app/mailers", "#{query.terms.join("_")}_mailer.rb")
+      when "channel"
+        File.join("app/channels", "#{query.terms.join("_")}_channel.rb")
+      when "public"
+        File.join("public", query.terms.join("/"))
+      end
+    end
+
+    def path_terms(path)
+      path.downcase.split(/[\/_.-]+/).reject(&:empty?)
+    end
+
+    def subsequence?(needles, haystack)
+      index = 0
+      needles.all? do |needle|
+        found = haystack[index..].find_index { |part| part.include?(needle) }
+        next false unless found
+
+        index += found + 1
+        true
+      end
+    end
+
+    def pluralize(term)
+      return term if term.end_with?("s") && !term.end_with?("ss")
+      return term.sub(/y\z/, "ies") if term.match?(/[^aeiou]y\z/)
+      return "#{term}es" if term.match?(/(s|x|z|ch|sh)\z/)
+
+      "#{term}s"
+    end
+
+    def singularize(term)
+      return term.sub(/ies\z/, "y") if term.end_with?("ies")
+      return term.sub(/ses\z/, "s") if term.end_with?("sses")
+      return term.delete_suffix("s") if term.end_with?("s") && !term.end_with?("ss") && !term.end_with?("us") && !term.end_with?("is")
+
+      term
+    end
+
+    def rails_project_root?(path)
+      File.directory?(File.join(path, "app")) && File.exist?(File.join(path, "config", "application.rb"))
+    end
+  end
+end

data/lib/rightnow/version.rb

@@ -0,0 +1,3 @@
+module RightNow
+  VERSION = "0.1.0"
+end

data/lib/rightnow.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "rightnow/version"
+require_relative "rightnow/query"
+require_relative "rightnow/resolver"
+require_relative "rightnow/cli"

data/right_now.gemspec

@@ -0,0 +1,21 @@
+require_relative "lib/rightnow/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "right_now"
+  spec.version = RightNow::VERSION
+  spec.summary = "Rails-aware file resolver"
+  spec.description = "rn resolves a user query to the most likely existing file in a Rails project."
+  spec.authors = ["SEAHAL"]
+  spec.homepage = "https://github.com/seahal/right_now"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+
+  spec.files = (Dir.glob("{exe,lib}/**/*", File::FNM_DOTMATCH) +
+                %w[README.md LICENSE right_now.gemspec]).select { |path| File.file?(path) }
+  spec.bindir = "exe"
+  spec.executables = %w[rn rni]
+  spec.require_paths = ["lib"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: right_now
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- SEAHAL
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: rn resolves a user query to the most likely existing file in a Rails
+  project.
+executables:
+- rn
+- rni
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/rn
+- exe/rni
+- lib/rightnow.rb
+- lib/rightnow/cli.rb
+- lib/rightnow/query.rb
+- lib/rightnow/resolver.rb
+- lib/rightnow/version.rb
+- right_now.gemspec
+homepage: https://github.com/seahal/right_now
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/seahal/right_now
+  source_code_uri: https://github.com/seahal/right_now
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Rails-aware file resolver
+test_files: []