Track actions taken against orgs

.flake8

@@ -1,7 +1,7 @@
 # Black-compatible flake8 config
 
 [flake8]
-ignore = E203, E266, E402, E501, W503, C901
+ignore = E203, E266, E402, E501, W503, C901, PYD001, PYD002
 max-line-length = 80
 max-complexity = 18
 select = B,C,E,F,W,T4,B9

cumulusci/cli/cci.py

@@ -1,5 +1,6 @@
 import code
 import contextlib
+import os
 import pdb
 import runpy
 import sys
@@ -20,6 +21,8 @@
 
 from .error import error
 from .flow import flow
+from .hash import hash_group
+from .history import history
 from .logger import get_tempfile_logger, init_logger
 from .org import org
 from .plan import plan
@@ -242,3 +245,5 @@ def shell(runtime, script=None, python=None):
 cli.add_command(flow)
 cli.add_command(plan)
 cli.add_command(robot)
+cli.add_command(hash_group)
+cli.add_command(history)

cumulusci/cli/flow.py

@@ -44,9 +44,9 @@ def flow_doc(runtime, project=False):
     flows_by_group = group_items(flows)
     flow_groups = sorted(
         flows_by_group.keys(),
-        key=lambda group: flow_info_groups.index(group)
-        if group in flow_info_groups
-        else 100,
+        key=lambda group: (
+            flow_info_groups.index(group) if group in flow_info_groups else 100
+        ),
     )
 
     for group in flow_groups:
@@ -162,13 +162,17 @@ def flow_run(runtime, flow_name, org, delete_org, debug, o, no_prompt):
                 )
 
     # Create the flow and handle initialization exceptions
+    coordinator = None
     try:
         coordinator = runtime.get_flow(flow_name, options=options)
         start_time = datetime.now()
         coordinator.run(org_config)
         duration = datetime.now() - start_time
         click.echo(f"Ran {flow_name} in {format_duration(duration)}")
-    except Exception:
+        org_config.add_action_to_history(coordinator.action)
+    except Exception as e:
+        if coordinator and coordinator.action:
+            org_config.add_action_to_history(coordinator.action)
         runtime.alert(f"Flow error: {flow_name}")
         raise
     finally:

cumulusci/cli/hash.py

@@ -0,0 +1,103 @@
+import click
+import hashlib
+import json
+import os
+from cumulusci.core.dependencies.resolvers import get_static_dependencies
+from cumulusci.core.utils import process_list_arg
+from cumulusci.utils.hashing import hash_obj
+from pydantic import BaseModel
+from .runtime import pass_runtime
+
+
+@click.group(
+    "hash",
+    help="Commands for hashing parts of the project's CumulusCI configuration and state",
+)
+def hash_group():
+    pass
+
+
+# Commands for group: hash
+
+
+@hash_group.command(
+    name="config",
+    help="Hashes all or part of the project's merged CumulusCI configuration",
+)
+@pass_runtime(require_project=True, require_keychain=False)  # maybe not needed...
+@click.option(
+    "--locators",
+    "locators",
+    help="A comma separated list of CumulusCI config locators to specify the top level of config key(s) to hash. Example: project__package,flows__ci_beta",
+)
+def hash_config(
+    runtime,
+    locators,
+):
+    locators_str = "for {}".format(locators) if locators else ""
+    locators = process_list_arg(locators)
+    config = runtime.project_config.config
+    if locators:
+        config = {loc: runtime.project_config.lookup(loc) for loc in locators}
+    config_hash = hash_obj(config)
+    click.echo(f"Hash of CumulusCI Config{locators_str}:")
+    click.echo(config_hash)
+    output_name = "HASH_CONFIG"
+    if locators:
+        output_name + "__" + "__AND__".join(locators)
+    ##set_github_output(output_name, config_hash)
+
+
+@hash_group.command(
+    name="flow",
+    help="Hashes a flow's configuration, either dynamic or frozen as a flat list of static steps",
+)
+@pass_runtime(require_project=True, require_keychain=False)  # maybe not needed...
+@click.argument("flow_name")
+@click.option(
+    "--freeze",
+    is_flag=True,
+    help="Freeze the flow configuration as a flat list of static steps",
+)
+def hash_flow(
+    runtime,
+    flow_name,
+    freeze,
+):
+    flow = runtime.get_flow(flow_name)
+
+    steps = flow.steps
+    if freeze:
+        steps = flow.freeze(org_config=None)
+    config_hash = hash_obj(steps)
+    click.echo(f"Hash of flow {flow_name}:")
+    click.echo(config_hash)
+    output_name = "HASH_FLOW__" + flow_name
+    if freeze:
+        output_name + "__FROZEN"
+    # set_github_output(output_name, config_hash)
+
+
+@hash_group.command(
+    name="dependencies",
+    help="Resolve and hash the project's current dependencies",
+)
+@click.option(
+    "--resolution-strategy",
+    help="The resolution strategy to use. Defaults to production.",
+    default="production",
+)
+@pass_runtime(require_keychain=True)
+def hash_dependencies(runtime, resolution_strategy):
+    resolved = get_static_dependencies(
+        runtime.project_config,
+        resolution_strategy=resolution_strategy,
+    )
+    dependencies = []
+    for dependency in resolved:
+        click.echo(dependency)
+        dependencies.append(dependency.dict())
+
+    deps_hash = hash_obj(dependencies)
+    click.echo(f"Hash of CumulusCI Dependencies for {resolution_strategy}:")
+    click.echo(deps_hash)