prompt_objects 0.1.0

data/lib/prompt_objects/environment/git.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Env
+    # Git operations for environments.
+    # Each environment is a git repository for built-in versioning.
+    module Git
+      # Check if a directory is a git repository.
+      # @param path [String]
+      # @return [Boolean]
+      def self.repo?(path)
+        Dir.exist?(File.join(path, ".git"))
+      end
+
+      # Initialize a git repository.
+      # @param path [String]
+      def self.init(path)
+        Dir.chdir(path) { system("git init --quiet") }
+      end
+
+      # Stage all changes.
+      # @param path [String]
+      def self.add_all(path)
+        Dir.chdir(path) { system("git add -A") }
+      end
+
+      # Create a commit.
+      # @param path [String]
+      # @param message [String]
+      # @return [Boolean] Success
+      def self.commit(path, message)
+        Dir.chdir(path) do
+          system("git add -A")
+          system("git", "commit", "--quiet", "-m", message)
+        end
+      end
+
+      # Get list of uncommitted changes.
+      # @param path [String]
+      # @return [Array<String>] Changed file paths
+      def self.uncommitted_changes(path)
+        Dir.chdir(path) do
+          status = `git status --porcelain 2>/dev/null`
+          status.lines.map { |line| line[3..].strip }
+        end
+      end
+
+      # Check if there are uncommitted changes.
+      # @param path [String]
+      # @return [Boolean]
+      def self.dirty?(path)
+        uncommitted_changes(path).any?
+      end
+
+      # Get current commit hash (short).
+      # @param path [String]
+      # @return [String, nil]
+      def self.current_commit(path)
+        Dir.chdir(path) do
+          result = `git rev-parse --short HEAD 2>/dev/null`.strip
+          result.empty? ? nil : result
+        end
+      end
+
+      # Get commit count.
+      # @param path [String]
+      # @return [Integer]
+      def self.commit_count(path)
+        Dir.chdir(path) do
+          `git rev-list --count HEAD 2>/dev/null`.strip.to_i
+        end
+      end
+
+      # Get recent commits.
+      # @param path [String]
+      # @param limit [Integer]
+      # @return [Array<Hash>] Array of {hash:, message:, date:}
+      def self.recent_commits(path, limit: 10)
+        Dir.chdir(path) do
+          log = `git log --oneline --format="%h|%s|%ci" -n #{limit} 2>/dev/null`
+          log.lines.map do |line|
+            hash, message, date = line.strip.split("|", 3)
+            { hash: hash, message: message, date: date }
+          end
+        end
+      end
+
+      # Create a git bundle for export.
+      # @param path [String]
+      # @param output [String] Output file path
+      # @return [Boolean] Success
+      def self.bundle(path, output)
+        Dir.chdir(path) do
+          system("git bundle create #{output} --all 2>/dev/null")
+        end
+      end
+
+      # Clone from a git bundle.
+      # @param bundle_path [String]
+      # @param dest_path [String]
+      # @return [Boolean] Success
+      def self.clone_bundle(bundle_path, dest_path)
+        system("git clone --quiet #{bundle_path} #{dest_path} 2>/dev/null")
+      end
+
+      # Auto-commit if there are changes (used for saving PO modifications).
+      # @param path [String]
+      # @param message [String]
+      # @return [Boolean] True if committed, false if no changes
+      def self.auto_commit(path, message = "Auto-save")
+        return false unless dirty?(path)
+
+        commit(path, message)
+        true
+      end
+    end
+  end
+end

data/lib/prompt_objects/environment/importer.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+module PromptObjects
+  module Env
+    # Imports an environment from a git bundle (.poenv file).
+    # Handles security concerns around custom primitives.
+    class Importer
+      # Result of inspecting a bundle before import
+      InspectResult = Struct.new(
+        :valid,
+        :name,
+        :description,
+        :objects,
+        :primitives,
+        :commits,
+        :error,
+        keyword_init: true
+      )
+
+      # @param bundle_path [String] Path to the .poenv bundle file
+      def initialize(bundle_path)
+        @bundle_path = File.expand_path(bundle_path)
+      end
+
+      # Inspect the bundle without importing it.
+      # Use this to show the user what's in the bundle before importing.
+      # @return [InspectResult]
+      def inspect_bundle
+        unless File.exist?(@bundle_path)
+          return InspectResult.new(valid: false, error: "Bundle file not found: #{@bundle_path}")
+        end
+
+        unless valid_bundle?
+          return InspectResult.new(valid: false, error: "Invalid git bundle file")
+        end
+
+        # Clone to temp dir to inspect contents
+        Dir.mktmpdir("poenv_inspect_") do |temp_dir|
+          unless Git.clone_bundle(@bundle_path, temp_dir)
+            return InspectResult.new(valid: false, error: "Failed to extract bundle")
+          end
+
+          gather_inspect_result(temp_dir)
+        end
+      end
+
+      # Import the bundle as a new environment.
+      # @param manager [Manager] Environment manager
+      # @param name [String] Name for the new environment
+      # @param trust_primitives [Boolean] Trust custom primitives (skip sandboxing)
+      # @return [Hash] Import result with :success, :path, :warnings
+      def import(manager:, name:, trust_primitives: false)
+        inspect_result = inspect_bundle
+        unless inspect_result.valid
+          return { success: false, error: inspect_result.error }
+        end
+
+        # Check if environment already exists
+        if manager.environment_exists?(name)
+          return { success: false, error: "Environment '#{name}' already exists" }
+        end
+
+        # Clone bundle to environment location
+        env_path = manager.environment_path(name)
+        unless Git.clone_bundle(@bundle_path, env_path)
+          return { success: false, error: "Failed to clone bundle" }
+        end
+
+        # Update manifest with new name if different
+        update_manifest(env_path, name)
+
+        # Build result with warnings about primitives
+        warnings = []
+        if inspect_result.primitives.any? && !trust_primitives
+          warnings << "This environment contains #{inspect_result.primitives.count} custom primitive(s):"
+          inspect_result.primitives.each do |prim|
+            warnings << "  - #{prim}"
+          end
+          warnings << "Custom primitives will be sandboxed by default."
+          warnings << "Review the code before trusting: #{File.join(env_path, 'primitives')}"
+        end
+
+        {
+          success: true,
+          path: env_path,
+          name: name,
+          objects: inspect_result.objects,
+          primitives: inspect_result.primitives,
+          warnings: warnings
+        }
+      end
+
+      # Check if a bundle contains custom primitives.
+      # @return [Boolean]
+      def has_primitives?
+        result = inspect_bundle
+        result.valid && result.primitives.any?
+      end
+
+      private
+
+      def valid_bundle?
+        # Git bundle verify returns 0 if valid
+        system("git bundle verify #{@bundle_path} >/dev/null 2>&1")
+      end
+
+      def gather_inspect_result(temp_dir)
+        objects_dir = File.join(temp_dir, "objects")
+        primitives_dir = File.join(temp_dir, "primitives")
+        manifest_path = File.join(temp_dir, "manifest.yml")
+
+        # Get manifest info
+        manifest_name = nil
+        manifest_desc = nil
+        if File.exist?(manifest_path)
+          manifest = YAML.safe_load(File.read(manifest_path))
+          manifest_name = manifest["name"]
+          manifest_desc = manifest["description"]
+        end
+
+        # List objects and primitives
+        objects = Dir.exist?(objects_dir) ? Dir.glob(File.join(objects_dir, "*.md")).map { |f| File.basename(f, ".md") } : []
+        primitives = Dir.exist?(primitives_dir) ? Dir.glob(File.join(primitives_dir, "*.rb")).map { |f| File.basename(f, ".rb") } : []
+
+        InspectResult.new(
+          valid: true,
+          name: manifest_name || File.basename(@bundle_path, ".poenv"),
+          description: manifest_desc,
+          objects: objects,
+          primitives: primitives,
+          commits: Git.commit_count(temp_dir)
+        )
+      end
+
+      def update_manifest(env_path, new_name)
+        manifest_path = File.join(env_path, "manifest.yml")
+        return unless File.exist?(manifest_path)
+
+        manifest = YAML.safe_load(File.read(manifest_path))
+        original_name = manifest["name"]
+
+        # Only update if name changed
+        return if original_name == new_name
+
+        manifest["name"] = new_name
+        manifest["imported_from"] = original_name
+        manifest["imported_at"] = Time.now.utc.iso8601
+
+        File.write(manifest_path, manifest.to_yaml)
+
+        # Commit the manifest change
+        Git.commit(env_path, "Imported as '#{new_name}' (from '#{original_name}')")
+      end
+    end
+  end
+end

data/lib/prompt_objects/environment/manager.rb

@@ -0,0 +1,401 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+
+module PromptObjects
+  module Env
+    # Manages multiple environments in the user's data directory.
+    # Handles creation, listing, opening, archiving environments.
+    class Manager
+      DEFAULT_BASE_DIR = File.expand_path("~/.prompt_objects")
+      ENVIRONMENTS_DIR = "environments"
+      ARCHIVE_DIR = "archive"
+      CONFIG_FILE = "config.yml"
+      DEV_ENV_NAME = "_development"
+
+      attr_reader :base_dir
+
+      def initialize(base_dir: nil)
+        @base_dir = base_dir || ENV.fetch("PROMPT_OBJECTS_HOME", DEFAULT_BASE_DIR)
+      end
+
+      # Ensure base directory structure exists.
+      def setup!
+        FileUtils.mkdir_p(environments_dir)
+        FileUtils.mkdir_p(archive_dir)
+        ensure_global_config
+      end
+
+      # Path to environments directory.
+      # @return [String]
+      def environments_dir
+        File.join(@base_dir, ENVIRONMENTS_DIR)
+      end
+
+      # Path to archive directory.
+      # @return [String]
+      def archive_dir
+        File.join(@base_dir, ARCHIVE_DIR)
+      end
+
+      # Path to global config file.
+      # @return [String]
+      def config_path
+        File.join(@base_dir, CONFIG_FILE)
+      end
+
+      # Load global config.
+      # @return [Hash]
+      def global_config
+        return {} unless File.exist?(config_path)
+
+        YAML.safe_load(File.read(config_path)) || {}
+      end
+
+      # Save global config.
+      # @param config [Hash]
+      def save_global_config(config)
+        File.write(config_path, config.to_yaml)
+      end
+
+      # Check if any environments exist.
+      # @return [Boolean]
+      def any_environments?
+        list.any?
+      end
+
+      # Check if first-run wizard should be shown.
+      # @return [Boolean]
+      def first_run?
+        !any_environments?
+      end
+
+      # List all environment names.
+      # @return [Array<String>]
+      def list
+        return [] unless Dir.exist?(environments_dir)
+
+        Dir.children(environments_dir)
+           .select { |name| environment_exists?(name) }
+           .reject { |name| name.start_with?("_") } # Hide dev environments
+           .sort
+      end
+
+      # List all environments with their manifests.
+      # @return [Array<Manifest>]
+      def list_with_manifests
+        list.map { |name| manifest_for(name) }.compact
+      end
+
+      # Check if an environment exists.
+      # @param name [String]
+      # @return [Boolean]
+      def environment_exists?(name)
+        path = environment_path(name)
+        Dir.exist?(path) && File.exist?(File.join(path, Env::Manifest::FILENAME))
+      end
+
+      # Get path to an environment.
+      # @param name [String]
+      # @return [String]
+      def environment_path(name)
+        File.join(environments_dir, name)
+      end
+
+      # Get manifest for an environment.
+      # @param name [String]
+      # @return [Manifest, nil]
+      def manifest_for(name)
+        return nil unless environment_exists?(name)
+
+        Manifest.load_from_dir(environment_path(name))
+      rescue StandardError
+        nil
+      end
+
+      # Create a new environment from a template.
+      # @param name [String] Environment name
+      # @param template [String, nil] Template name (from templates/)
+      # @param description [String, nil] Environment description
+      # @return [String] Path to created environment
+      def create(name:, template: nil, description: nil)
+        raise Error, "Environment '#{name}' already exists" if environment_exists?(name)
+        raise Error, "Invalid environment name: #{name}" unless valid_name?(name)
+
+        env_path = environment_path(name)
+        FileUtils.mkdir_p(env_path)
+        FileUtils.mkdir_p(File.join(env_path, "objects"))
+        FileUtils.mkdir_p(File.join(env_path, "primitives"))
+
+        # Copy template if specified
+        template_manifest = copy_template(env_path, template) if template
+
+        # Create manifest
+        manifest = Manifest.new(
+          name: name,
+          description: description || template_manifest&.dig("description"),
+          icon: template_manifest&.dig("icon") || "📦",
+          color: template_manifest&.dig("color") || "#4A90D9"
+        )
+        manifest.save_to_dir(env_path)
+
+        # Create .gitignore
+        create_gitignore(env_path)
+
+        # Initialize git repo
+        init_git(env_path)
+
+        env_path
+      end
+
+      # Create the development environment (for --dev flag).
+      # Uses minimal template to ensure at least one PO exists for bootstrapping.
+      # @return [String] Path to dev environment
+      def create_dev_environment
+        return environment_path(DEV_ENV_NAME) if environment_exists?(DEV_ENV_NAME)
+
+        env_path = environment_path(DEV_ENV_NAME)
+        FileUtils.mkdir_p(env_path)
+        FileUtils.mkdir_p(File.join(env_path, "objects"))
+        FileUtils.mkdir_p(File.join(env_path, "primitives"))
+
+        # Copy minimal template objects for bootstrapping
+        copy_template(env_path, "minimal")
+
+        manifest = Manifest.new(
+          name: DEV_ENV_NAME,
+          description: "Development environment",
+          icon: "🔧"
+        )
+        manifest.save_to_dir(env_path)
+
+        create_gitignore(env_path)
+        init_git(env_path)
+
+        env_path
+      end
+
+      # Get path to development environment.
+      # @return [String]
+      def dev_environment_path
+        create_dev_environment
+      end
+
+      # Archive (soft delete) an environment.
+      # @param name [String]
+      # @return [String] Path to archived environment
+      def archive(name)
+        raise Error, "Environment '#{name}' not found" unless environment_exists?(name)
+        raise Error, "Cannot archive development environment" if name == DEV_ENV_NAME
+
+        src = environment_path(name)
+
+        # Mark as archived in manifest before moving
+        manifest = Manifest.load_from_dir(src)
+        manifest.mark_archived!
+        manifest.save_to_dir(src)
+
+        # Commit the archive marker
+        Git.commit(src, "Archived environment")
+
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        dest = File.join(archive_dir, "#{name}_#{timestamp}")
+
+        FileUtils.mv(src, dest)
+        dest
+      end
+
+      # List archived environments.
+      # @return [Array<String>]
+      def list_archived
+        return [] unless Dir.exist?(archive_dir)
+
+        Dir.children(archive_dir).sort
+      end
+
+      # Restore an archived environment.
+      # @param archived_name [String] Name with timestamp suffix
+      # @param restore_as [String, nil] New name (defaults to original name)
+      # @return [String] Path to restored environment
+      def restore(archived_name, restore_as: nil)
+        src = File.join(archive_dir, archived_name)
+        raise Error, "Archived environment not found: #{archived_name}" unless Dir.exist?(src)
+
+        # Extract original name (remove timestamp suffix)
+        original_name = archived_name.sub(/_\d{8}_\d{6}$/, "")
+        new_name = restore_as || original_name
+
+        raise Error, "Environment '#{new_name}' already exists" if environment_exists?(new_name)
+
+        dest = environment_path(new_name)
+        FileUtils.mv(src, dest)
+
+        # Update manifest: clear archived_at, update name if needed
+        manifest = Manifest.load_from_dir(dest)
+        manifest.archived_at = nil
+        manifest.name = new_name if new_name != original_name
+        manifest.save_to_dir(dest)
+
+        # Commit the restore
+        Git.commit(dest, "Restored environment#{new_name != original_name ? " as '#{new_name}'" : ""}")
+
+        dest
+      end
+
+      # Permanently delete an archived environment.
+      # @param archived_name [String]
+      def delete_archived(archived_name)
+        path = File.join(archive_dir, archived_name)
+        raise Error, "Archived environment not found: #{archived_name}" unless Dir.exist?(path)
+
+        FileUtils.rm_rf(path)
+      end
+
+      # Clone an environment.
+      # @param source_name [String]
+      # @param new_name [String]
+      # @return [String] Path to cloned environment
+      def clone(source_name, new_name)
+        raise Error, "Source environment '#{source_name}' not found" unless environment_exists?(source_name)
+        raise Error, "Environment '#{new_name}' already exists" if environment_exists?(new_name)
+        raise Error, "Invalid environment name: #{new_name}" unless valid_name?(new_name)
+
+        src = environment_path(source_name)
+        dest = environment_path(new_name)
+
+        # Copy directory (excluding sessions.db)
+        FileUtils.mkdir_p(dest)
+        Dir.glob(File.join(src, "**", "*"), File::FNM_DOTMATCH).each do |path|
+          relative = path.sub("#{src}/", "")
+          next if relative == "." || relative == ".."
+          next if relative.include?("sessions.db")
+          next if relative.start_with?(".git/")
+
+          target = File.join(dest, relative)
+          if File.directory?(path)
+            FileUtils.mkdir_p(target)
+          else
+            FileUtils.cp(path, target)
+          end
+        end
+
+        # Update manifest
+        manifest = Manifest.load_from_dir(dest)
+        manifest.name = new_name
+        manifest.instance_variable_set(:@created_at, Time.now)
+        manifest.instance_variable_set(:@stats, { "total_messages" => 0, "total_sessions" => 0, "po_count" => manifest.stats["po_count"] })
+        manifest.save_to_dir(dest)
+
+        # Initialize fresh git repo
+        init_git(dest)
+
+        dest
+      end
+
+      # Get default environment name from config.
+      # @return [String, nil]
+      def default_environment
+        global_config["default_environment"]
+      end
+
+      # Set default environment.
+      # @param name [String]
+      def set_default_environment(name)
+        raise Error, "Environment '#{name}' not found" unless environment_exists?(name)
+
+        config = global_config
+        config["default_environment"] = name
+        save_global_config(config)
+      end
+
+      private
+
+      # Validate environment name.
+      # @param name [String]
+      # @return [Boolean]
+      def valid_name?(name)
+        return false if name.nil? || name.empty?
+        return false if name.start_with?("_") # Reserved for system envs
+        return false unless name.match?(/\A[a-zA-Z0-9_-]+\z/)
+
+        true
+      end
+
+      # Copy template files to environment.
+      # @param env_path [String]
+      # @param template_name [String]
+      # @return [Hash, nil] Template manifest data
+      def copy_template(env_path, template_name)
+        template_path = find_template(template_name)
+        raise Error, "Template '#{template_name}' not found" unless template_path
+
+        # Read template manifest
+        template_manifest_path = File.join(template_path, "manifest.yml")
+        template_manifest = if File.exist?(template_manifest_path)
+                              YAML.safe_load(File.read(template_manifest_path))
+                            end
+
+        # Copy objects
+        template_objects = File.join(template_path, "objects")
+        if Dir.exist?(template_objects)
+          FileUtils.cp_r(Dir.glob("#{template_objects}/*"), File.join(env_path, "objects"))
+        end
+
+        # Copy primitives if present
+        template_primitives = File.join(template_path, "primitives")
+        if Dir.exist?(template_primitives)
+          FileUtils.cp_r(Dir.glob("#{template_primitives}/*"), File.join(env_path, "primitives"))
+        end
+
+        template_manifest
+      end
+
+      # Find template directory.
+      # @param name [String]
+      # @return [String, nil]
+      def find_template(name)
+        # Look in gem's templates directory
+        gem_templates = File.expand_path("../../../../templates", __FILE__)
+        path = File.join(gem_templates, name)
+        return path if Dir.exist?(path)
+
+        nil
+      end
+
+      # Create .gitignore for environment.
+      # @param env_path [String]
+      def create_gitignore(env_path)
+        gitignore_content = <<~GITIGNORE
+          # Session data (private)
+          sessions.db
+          sessions.db-journal
+          sessions.db-wal
+          sessions.db-shm
+        GITIGNORE
+
+        File.write(File.join(env_path, ".gitignore"), gitignore_content)
+      end
+
+      # Initialize git repository.
+      # @param env_path [String]
+      def init_git(env_path)
+        Dir.chdir(env_path) do
+          system("git init --quiet")
+          system("git add .")
+          system("git commit --quiet -m 'Initial environment setup'")
+        end
+      end
+
+      # Ensure global config file exists.
+      def ensure_global_config
+        return if File.exist?(config_path)
+
+        save_global_config({
+          "default_environment" => nil,
+          "trusted_primitives" => []
+        })
+      end
+    end
+  end
+end