starbash 0.1.11__py3-none-any.whl → 0.1.15__py3-none-any.whl

starbash/tool.py

@@ -1,17 +1,43 @@
+import logging
 import os
+import re
 import shutil
-import textwrap
-import tempfile
 import subprocess
-import re
-import threading
-import queue
-import logging
+import tempfile
+import textwrap
+from typing import Any
+
 import RestrictedPython
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.traceback import Traceback
+
+from starbash.commands import SPINNER_STYLE
+from starbash.exception import UserHandledError
 
 logger = logging.getLogger(__name__)
 
 
+class ToolError(UserHandledError):
+    """Exception raised when a tool fails to execute properly."""
+
+    def __init__(self, *args: object, command: str, arguments: str | None) -> None:
+        super().__init__(*args)
+        self.command = command
+        self.arguments = arguments
+
+    def ask_user_handled(self) -> bool:
+        from starbash import console  # Lazy import to avoid circular dependency
+
+        console.print(
+            f"'{self.command}' failed while running [bold red]{self.arguments}[/bold red]"
+        )
+        return True
+
+    def __rich__(self) -> Any:
+        return f"Tool: [red]'{self.command}'[/red] failed"
+
+
 class _SafeFormatter(dict):
     """A dictionary for safe string formatting that ignores missing keys during expansion."""
 
@@ -30,7 +56,7 @@ def expand_context(s: str, context: dict) -> str:
     expanded = s
     previous = None
     max_iterations = 10  # Safety break for infinite recursion
-    for i in range(max_iterations):
+    for _i in range(max_iterations):
         if expanded == previous:
             break  # Expansion is complete
         previous = expanded
@@ -161,14 +187,8 @@ def strip_comments(text: str) -> str:
     return "\n".join(lines)
 
 
-def tool_run(
-    cmd: str, cwd: str, commands: str | None = None, timeout: float | None = None
-) -> None:
-    """Executes an external tool with an optional script of commands in a given working directory.
-
-    Streams stdout and stderr in real-time to the logger, allowing you to see subprocess output
-    as it happens rather than waiting for completion.
-    """
+def tool_run(cmd: str, cwd: str, commands: str | None = None, timeout: float | None = None) -> None:
+    """Executes an external tool with an optional script of commands in a given working directory."""
 
     logger.debug(f"Running {cmd} in {cwd}: stdin={commands}")
 
@@ -183,111 +203,39 @@ def tool_run(
         cwd=cwd,
     )
 
-    # Send commands to stdin if provided
-    if commands and process.stdin:
-        try:
-            process.stdin.write(commands)
-            process.stdin.close()
-        except BrokenPipeError:
-            # Process may have terminated early
-            pass
-
-    # Stream output line by line in real-time
-    # Use threading for cross-platform compatibility (select doesn't work on Windows with pipes)
-
-    assert process.stdout
-    assert process.stderr
-
-    output_queue: queue.Queue = queue.Queue()
-
-    def read_stream(stream, log_func, stream_name):
-        """Read from stream and put lines in queue."""
-        try:
-            for line in stream:
-                line = line.rstrip("\n")
-                output_queue.put((log_func, stream_name, line))
-        finally:
-            output_queue.put((None, stream_name, None))  # Signal EOF
-
-    # Start threads to read stdout and stderr
-    stdout_thread = threading.Thread(
-        target=read_stream,
-        args=(process.stdout, logger.debug, "tool-stdout"),
-        daemon=True,
-    )
-    stderr_thread = threading.Thread(
-        target=read_stream,
-        args=(process.stderr, logger.warning, "tool-stderr"),
-        daemon=True,
-    )
-
-    stdout_thread.start()
-    stderr_thread.start()
-
-    # Track which streams have finished
-    streams_finished = 0
-
+    # Wait for process to complete with timeout
     try:
-        # Process output from queue until both streams are done
-        while streams_finished < 2:
-            try:
-                # Use timeout to periodically check if process has terminated
-                log_func, stream_name, line = output_queue.get(timeout=0.1)
-
-                if log_func is None:
-                    # EOF signal
-                    streams_finished += 1
-                else:
-                    # Log the line
-                    log_func(f"[{stream_name}] {line}")
-
-            except queue.Empty:
-                # No output available, check if process terminated
-                if process.poll() is not None:
-                    # Process finished, wait a bit more for remaining output
-                    break
-
-        # Wait for threads to finish (they should be done or very close)
-        stdout_thread.join(timeout=1.0)
-        stderr_thread.join(timeout=1.0)
-
-        # Drain any remaining items in queue
-        while not output_queue.empty():
-            try:
-                log_func, stream_name, line = output_queue.get_nowait()
-                if log_func is not None:
-                    log_func(f"[{stream_name}] {line}")
-            except queue.Empty:
-                break
-
-        # Wait for process to complete with timeout
-        try:
-            process.wait(timeout=timeout)
-        except subprocess.TimeoutExpired:
-            process.kill()
-            process.wait()
-            raise RuntimeError(f"Tool timed out after {timeout} seconds")
+        stdout_lines, stderr_lines = process.communicate(input=commands, timeout=timeout)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        stdout_lines, stderr_lines = process.communicate()
+        raise RuntimeError(f"Tool timed out after {timeout} seconds")
+
+    returncode = process.returncode
+
+    if stderr_lines:
+        logger.warning(f"[tool-warnings] {stderr_lines}")
+
+    if returncode != 0:
+        # log stdout with warn priority because the tool failed
+        logger.warning(f"[tool] {stdout_lines}")
+        raise ToolError(
+            f"{cmd} failed with exit code {returncode}", command=cmd, arguments=commands
+        )
+    else:
+        logger.debug(f"[tool] {stdout_lines}")
+        logger.debug("Tool command successful.")
 
-        returncode = process.returncode
 
-        if returncode != 0:
-            raise RuntimeError(f"Tool failed with exit code {returncode}")
-        else:
-            logger.debug("Tool command successful.")
-    finally:
-        # Ensure streams are properly closed
-        if process.stdout:
-            process.stdout.close()
-        if process.stderr:
-            process.stderr.close()
+class MissingToolError(UserHandledError):
+    """Exception raised when a required tool is not found."""
 
+    def __init__(self, *args: object, command: str) -> None:
+        super().__init__(*args)
+        self.command = command
 
-def executable_path(commands: list[str], name: str) -> str:
-    """Find the correct executable path to run for the given tool"""
-    for cmd in commands:
-        if shutil.which(cmd):
-            return cmd
-    raise FileNotFoundError(f"{name} not found, you probably need to install it.")
+    def __rich__(self) -> Any:
+        return str(self)  # FIXME do something better here?
 
 
 class Tool:
@@ -303,34 +251,83 @@ class Tool:
     def set_defaults(self):
         # default timeout in seconds, if you need to run a tool longer than this, you should change
         # it before calling run()
-        self.timeout = 10.0
+        self.timeout = (
+            5 * 60.0  # 5 minutes - just to make sure we eventually stop all tools
+        )
+
+    def run(self, commands: str, context: dict = {}, cwd: str | None = None) -> None:
+        """Run commands inside this tool
 
-    def run_in_temp_dir(self, commands: str, context: dict = {}) -> None:
-        """Run commands inside this tool (with cwd pointing to a temp directory)"""
-        # Create a temporary directory for processing
-        temp_dir = tempfile.mkdtemp(prefix=self.name)
+        If cwd is provided, use that as the working directory otherwise a temp directory is used as cwd.
+        """
+        from starbash import console  # Lazy import to avoid circular dependency
 
-        context["temp_dir"] = (
-            temp_dir  # pass our directory path in for the tool's usage
+        temp_dir = None
+        spinner = Spinner(
+            "arc", text=f"Tool running: [bold]{self.name}[/bold]...", speed=2.0, style=SPINNER_STYLE
         )
+        with Live(spinner, console=console, refresh_per_second=5):
+            try:
+                if not cwd:
+                    # Create a temporary directory for processing
+                    cwd = temp_dir = tempfile.mkdtemp(prefix=self.name)
+
+                    context["temp_dir"] = (
+                        temp_dir  # pass our directory path in for the tool's usage
+                    )
+
+                self._run(cwd, commands, context=context)
+            finally:
+                spinner.update(text=f"Tool completed: [bold]{self.name}[/bold].")
+                if temp_dir:
+                    shutil.rmtree(temp_dir)
+                    context.pop("temp_dir", None)
+
+    def _run(self, cwd: str, commands: str, context: dict = {}) -> None:
+        """Run commands inside this tool (with cwd pointing to the specified directory)"""
+        raise NotImplementedError()
+
 
+class ExternalTool(Tool):
+    """A tool provided by an external executable"""
+
+    def __init__(self, name: str, commands: list[str], install_url: str) -> None:
+        super().__init__(name)
+        self.commands = commands
+        self.install_url = install_url
+
+    def preflight(self) -> None:
+        """Check that the tool is available"""
         try:
-            self.run(temp_dir, commands, context=context)
-        finally:
-            shutil.rmtree(temp_dir)
+            _ = self.executable_path  # raise if not found
+        except MissingToolError:
+            logger.warning(
+                textwrap.dedent(f"""\
+                    The {self.name} executable was not found.  Some features will be unavailable until you install it.
+                    Click [link={self.install_url}]here[/link] for installation instructions.""")
+            )
 
-    def run(self, cwd: str, commands: str, context: dict = {}) -> None:
-        """Run commands inside this tool (with cwd pointing to the specified directory)"""
-        raise NotImplementedError()
+    @property
+    def executable_path(self) -> str:
+        """Find the correct executable path to run for the given tool"""
+        for cmd in self.commands:
+            if shutil.which(cmd):
+                return cmd
+        raise MissingToolError(
+            f"{self.name} not found. Installation instructions [link={self.install_url}]here[/link]",
+            command=self.name,
+        )
 
 
-class SirilTool(Tool):
+class SirilTool(ExternalTool):
     """Expose Siril as a tool"""
 
     def __init__(self) -> None:
-        super().__init__("siril")
+        # siril_path = "/home/kevinh/packages/Siril-1.4.0~beta3-x86_64.AppImage"
+        # Possible siril commands, with preferred option first
+        super().__init__("siril", ["siril-cli", "siril", "org.siril.Siril"], "https://siril.org/")
 
-    def run(self, cwd: str, commands: str, context: dict = {}) -> None:
+    def _run(self, cwd: str, commands: str, context: dict = {}) -> None:
         """Executes Siril with a script of commands in a given working directory."""
 
         # Iteratively expand the command string to handle nested placeholders.
@@ -341,10 +338,7 @@ class SirilTool(Tool):
 
         temp_dir = cwd
 
-        # siril_path = "/home/kevinh/packages/Siril-1.4.0~beta3-x86_64.AppImage"
-        # Possible siril commands, with preferred option first
-        siril_commands = ["org.siril.Siril", "siril-cli", "siril"]
-        siril_path = executable_path(siril_commands, "Siril")
+        siril_path = self.executable_path
         if siril_path == "org.siril.Siril":
             # The executable is inside a flatpak, so run the lighter/faster/no-gui required exe
             # from inside the flatpak
@@ -352,10 +346,14 @@ class SirilTool(Tool):
 
         # Create symbolic links for all input files in the temp directory
         for f in input_files:
-            os.symlink(
-                os.path.abspath(str(f)),
-                os.path.join(temp_dir, os.path.basename(str(f))),
-            )
+            dest_file = os.path.join(temp_dir, os.path.basename(str(f)))
+
+            # if a script is re-run we might already have the input file symlinks
+            if not os.path.exists(dest_file):
+                os.symlink(
+                    os.path.abspath(str(f)),
+                    dest_file,
+                )
 
         # We dedent here because the commands are often indented multiline strings
         script_content = textwrap.dedent(
@@ -377,21 +375,53 @@ class SirilTool(Tool):
         tool_run(cmd, temp_dir, script_content, timeout=self.timeout)
 
 
-class GraxpertTool(Tool):
+class GraxpertTool(ExternalTool):
     """Expose Graxpert as a tool"""
 
     def __init__(self) -> None:
-        super().__init__("graxpert")
+        super().__init__("graxpert", ["graxpert"], "https://graxpert.com/")
 
-    def run(self, cwd: str, commands: str, context: dict = {}) -> None:
+    def _run(self, cwd: str, commands: str, context: dict = {}) -> None:
         """Executes Graxpert with the specified command line arguments"""
 
         # Arguments look similar to: graxpert -cmd background-extraction -output /tmp/testout tests/test_images/real_crummy.fits
-        cmd = f"graxpert {commands}"
+        cmd = f"{self.executable_path} {commands}"
 
         tool_run(cmd, cwd, timeout=self.timeout)
 
 
+class PythonScriptError(UserHandledError):
+    """Exception raised when an error occurs during Python script execution."""
+
+    def ask_user_handled(self) -> bool:
+        """Prompt the user with a friendly message about the error.
+        Returns:
+            True if the error was handled, False otherwise.
+        """
+        from starbash import console  # Lazy import to avoid circular dependency
+
+        console.print(
+            """[bold red]Python Script Error[/bold red] please contact the script author and
+            give them this information.
+
+            Processing for the current file will be skipped..."""
+        )
+
+        # Show the traceback with Rich formatting
+        if self.__cause__:
+            traceback = Traceback.from_exception(
+                type(self.__cause__),
+                self.__cause__,
+                self.__cause__.__traceback__,
+                show_locals=True,
+            )
+            console.print(traceback)
+        else:
+            console.print(f"[yellow]{str(self)}[/yellow]")
+
+        return True
+
+
 class PythonTool(Tool):
     """Expose Python as a tool"""
 
@@ -401,7 +431,7 @@ class PythonTool(Tool):
         # default script file override
         self.default_script_file = "starbash.py"
 
-    def run(self, cwd: str, commands: str, context: dict = {}) -> None:
+    def _run(self, cwd: str, commands: str, context: dict = {}) -> None:
         original_cwd = os.getcwd()
         try:
             os.chdir(cwd)  # cd to where this script expects to run
@@ -416,14 +446,21 @@ class PythonTool(Tool):
                 globals = {"context": context}
                 exec(byte_code, make_safe_globals(globals), execution_locals)
             except SyntaxError as e:
-                raise  # Just rethrow - no need to rewrap
+                raise PythonScriptError("Syntax error in python script") from e
+            except UserHandledError:
+                raise  # No need to wrap this - just pass it through for user handling
             except Exception as e:
-                raise ValueError(f"Error during python script execution") from e
+                raise PythonScriptError("Error during python script execution") from e
         finally:
             os.chdir(original_cwd)
 
 
+def preflight_tools() -> None:
+    """Preflight check all known tools to see if they are available"""
+    for tool in tools.values():
+        if isinstance(tool, ExternalTool):
+            tool.preflight()
+
+
 # A dictionary mapping tool names to their respective tool instances.
-tools: dict[str, Tool] = {
-    tool.name: tool for tool in [SirilTool(), GraxpertTool(), PythonTool()]
-}
+tools: dict[str, Tool] = {tool.name: tool for tool in [SirilTool(), GraxpertTool(), PythonTool()]}

starbash-0.1.15.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: starbash
+Version: 0.1.15
+Summary: A tool for automating/standardizing/sharing astrophotography workflows.
+License-File: LICENSE
+Author: Kevin Hester
+Author-email: kevinh@geeksville.com
+Requires-Python: >=3.12,<3.15
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: astropy (>=7.1.1,<8.0.0)
+Requires-Dist: multidict (>=6.7.0,<7.0.0)
+Requires-Dist: platformdirs (>=4.5.0,<5.0.0)
+Requires-Dist: restrictedpython (>=8.1,<9.0)
+Requires-Dist: rich (>=14.2.0,<15.0.0)
+Requires-Dist: sentry-sdk (>=2.42.1,<3.0.0)
+Requires-Dist: tomlkit (>=0.13.3,<0.14.0)
+Requires-Dist: typer (>=0.20.0,<0.21.0)
+Requires-Dist: update-checker (>=0.18.0,<0.19.0)
+Description-Content-Type: text/markdown
+
+# [Starbash](https://github.com/geeksville/starbash)
+
+<img src="https://raw.githubusercontent.com/geeksville/starbash/refs/heads/main/img/icon.png" alt="Starbash: Astrophotography workflows simplified" width="30%" align="right" style="margin-bottom: 20px;">
+
+[![PyPI - Version](https://img.shields.io/pypi/v/starbash)](https://pypi.org/project/starbash/)
+[![GitHub branch check runs](https://img.shields.io/github/check-runs/geeksville/starbash/main)](https://github.com/geeksville/starbash/actions)
+[![codecov](https://codecov.io/github/geeksville/starbash/graph/badge.svg?token=47RE10I7O1)](https://codecov.io/github/geeksville/starbash)
+
+A tool for automating/standardizing/sharing astrophotography workflows.
+
+* Automatic - with sensible defaults that you can change as needed.
+* Easy - provides a 'seestar-like' starting point for autoprocessing all your sessions (by default).
+* Fast - even with large image repositories.  Automatic master bias and flat generation and reasonable defaults.
+* Multi-session - by default.  So your workflows can stack from multiple nights (and still use the correct flats etc...).
+* Shareable - you can share/use recipes for image preprocessing flows.
+
+(This project is currently 'alpha' and missing recipes for some workflows, but adding new recipes is easy and we're happy to help.  Please file a GitHub issue if your images are not auto-processed and we'll work out a fix.)
+
+<br clear="right">
+
+# Current status
+
+This project is still very young - but making good progress 😊!
+
+If you are interested in alpha-testing we ❤️ you.  This README should have enough instructions to get you going, but if you encounter **any** problems please file a github issue and we'll work together to fix them.
+
+![Sample session movie](https://raw.githubusercontent.com/geeksville/starbash/refs/heads/main/doc/vhs/sample-session.gif)
+
+## Current features
+
+* Automatically recognizes and auto-parses the default NINA, Asiair, and Seestar raw file repos (adding support for other layouts is easy).
+* Multi-session support by default (including automatic selection of correct flats, biases, and dark frames).
+* 'Repos' can contain raw files, generated masters, preprocessed files, or recipes.
+* Automatically performs **complete** preprocessing on OSC (broadband, narrowband, or dual Duo filter), Mono (LRGB, SHO) data.  i.e., gives you 'seestar-level' auto-preprocessing, so you only need to do the (optional) custom post-processing.
+
+## Features coming soon
+
+* Support for mono-camera workflows (this alpha version only supports color cameras).
+* Generates a per-target report/config file which can be customized if the detected defaults or preprocessing are not what you want.
+* 'Recipes' provide repeatable/human-readable/shareable descriptions of all processing steps.
+* Repos can be on the local disk or shared via HTTPS/GitHub/etc.  This is particularly useful for recipe repos.
+* Uses Siril and Graxpert for its pre-processing operations (support for Pixinsight-based recipes will probably be coming at some point...).
+* The target report can be used to auto-generate a human-friendly 'postable/shareable' report about that image.
+* Target reports are shareable so that you can request comments from others and others can rerender with different settings.
+
+See the [TODO](TODO.md) file for work items and approximate schedule.
+
+## Installing
+
+Currently the easiest way to install this command-line based tool is via [pipx](https://pipx.pypa.io/stable/).  If you don't already have pipx and you have Python installed, you can auto-install it by running "pip install --user pipx."  If you don't have Python installed see the pipx link for pipx installers for any OS.
+
+Once pipx is installed just run the following **two** commands (the `sb --install-completion` will make TAB auto-complete automatically complete `sb` options for most platforms).  Installing auto-complete is **highly** recommended because it makes entering starbash commands fast by pressing the TAB key:
+
+```
+➜ pipx install starbash
+  installed package starbash 0.1.3, installed using Python 3.12.3
+  These apps are now globally available
+    - sb
+    - starbash
+done! ✨ 🌟 ✨
+
+➜ sb --install-completion
+bash completion installed in /home/.../sb.sh
+Completion will take effect once you restart the terminal
+
+```
+
+## Use
+
+### Initial setup
+
+The first time you launch starbash you will be prompted to choose a few options. You will also be told how you can add your existing raw frames and an input repo.
+
+![user setup](doc/img/user-setup.png)
+
+If you ever want to rerun this setup just run 'sb user setup'
+
+### Automatic stacking/preprocessing
+
+One of the main goals of starbash is to provide 'seestar-like' automatic image preprocessing:
+* automatic stacking (even over multiple sessions) - (via Siril)
+* automatic recipe selection (color, bw, duo filters etc...), but you can customize if starbash picks poorly
+* background removal - (via Graxpert by default) provided as extra (optional) output files
+* star removal - (via Starnet by default) provided as extra (optional) output files
+* no changes to input repos - you can safely ask starbash to auto-process your entire tree of raw images.  Processed images go in a special 'processed' output repo.
+
+![auto session](doc/vhs/process-auto.gif)
+
+How to use:
+
+* Step 1 - Select some sessions.  Example commands to use (when running commands the tool will provide feedback on what the current session set contains):
+
+```
+sb select any # selects all sessions in your repo
+sb select # prints information about the current selection
+sb select list # lists all sessions in the current selection
+sb select date after 2025-09-01
+sb select date before 2025-10-01
+sb select date between 2025-07-03 2025-10-01
+
+sb select target m31 # select all sessions with m31.
+# Note: tab completion is supported so if you type select target m<tab> you should get a list of all the Messier objects you have in your images.
+# In fact, tab completion works on virtually any starbash option - pressing tab for dates will show you dates you have image sessions for instance...
+```
+
+* Step 2 - Generate 'master' images.  This will auto-stack your raw BIAS, DARK, FLAT etc... frames as single frame masters.  You only need to perform this step once:
+
+```
+sb process masters
+```
+
+* Step 3 - Do auto-process.  This will process all of the sessions you currently have selected.  It will group outputs by target name and it will auto-select flat frames on a per-session-date basis.  At the end of processing a list of targets and their processing will be printed.
+
+```
+sb process auto
+```
+
+In the output directory we will eventually be putting a 'starbash.toml' file with information about what choices were made during processing (which masters selected, which recipes selected..., selected Siril options, etc...). You can edit that file to pick different choices and if you reprocess that target your choices will be used.  (Note: this is not yet implemented in the release version of the tool - but soon.)
+
+### Manual Siril processing
+
+FIXME - add getting started instructions (possibly with a screenshare video)
+
+![siril session](doc/vhs/process-siril.gif)
+
+## Supported commands
+
+### Repository Management
+- `sb repo list [--verbose]` - List installed repos (use `-v` for details)
+- `sb repo add [--master] [filepath|URL]` - Add a repository, optionally specifying the type
+- `sb repo remove <REPOURL>` - Remove the indicated repo from the repo list
+- `sb repo reindex [--force] <REPOURL>` - Reindex the specified repo (or all repos if none specified)
+
+### User Preferences
+- `sb user name "Your Name"` - Set name for attribution in generated images
+- `sb user email "foo@example.com"` - Set email for attribution in generated images
+- `sb user analytics <on|off>` - Turn analytics collection on/off
+- `sb user setup` - Configure starbash via a brief guided process
+
+### Selection & Filtering
+- `sb select` - Show information about the current selection
+- `sb select list` - List sessions (filtered based on the current selection)
+- `sb select any` - Remove all filters (select everything)
+- `sb select target <TARGETNAME>` - Limit selection to the named target
+- `sb select telescope <TELESCOPENAME>` - Limit selection to the named telescope
+- `sb select date <after|before|between> <DATE> [DATE]` - Limit to sessions in the specified date range
+- `sb select export SESSIONNUM DESTDIR` - Export the images for the indicated session number into the specified directory (or current directory if not specified).  If possible, symbolic links are used; if not, the files are copied.
+
+### Selection information
+- `sb info` - Show user preferences location and other app info
+- `sb info target` - List targets (filtered based on the current selection)
+- `sb info telescope` - List instruments (filtered based on the current selection)
+- `sb info filter` - List all filters found in current selection
+- `sb info master [KIND]` - List all precalculated master images (darks, biases, flats). Optional KIND argument to filter by image type (e.g., BIAS, DARK, FLAT).
+
+## Not yet supported commands
+
+### Export & Processing
+- `sb process siril [--run] SESSIONNUM DESTDIR` - Generate Siril directory tree and optionally run Siril GUI.
+- `sb process auto [SESSIONNUM]` - Automatic processing.  If session # is specified, process only that session; otherwise all selected sessions will be processed.
+- `sb process masters` - Generate master flats, darks, and biases from available raw frames in the current selection.
+
+## Supported telescope software
+
+FIXME explain FITS and directory paths
+
+* N.I.N.A. - tested, seems fairly okay.
+* Asiair - tested, seems fairly okay.
+* Seestar - tested, seems fairly okay.
+* Ekos/Kstars - not tested; please try it and file a GitHub issue if you see any problems.
+
+## Supported tools (now)
+
+* Siril
+* Graxpert
+* Python (you can add Python code to recipes if necessary)
+
+## Supported tools (future?)
+
+* Pixinsight?
+* Autostakkert?
+
+## Development
+
+We try to make this project useful and friendly.  If you find problems please file a GitHub issue.
+We accept pull-requests and enjoy discussing possible new development directions via GitHub issues.  If you might want to work on this, just describe what your interests are and we can talk about how to get it merged.
+
+[Click here](doc/development.md) for the current work in progress developer docs.  They will get better before our beta release...
+
+## License
+
+Copyright 2025 Kevin Hester, kevinh@geeksville.com.
+Licensed under the [GPL v3](LICENSE)