loopmath 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- loopmath/__init__.py +1 -1
- loopmath/cli.py +1 -1
- loopmath/cli_registry.py +13 -8
- loopmath/onboard/commands.py +1 -1
- loopmath/skill/commands.py +17 -19
- loopmath/skill/doctor.py +30 -6
- loopmath/skill/guide.py +52 -0
- loopmath/skill/{skills/loopmath-update-fit/SKILL.md → guides/fit.md} +2 -8
- loopmath/skill/{skills/loopmath-import-runs/SKILL.md → guides/import.md} +1 -7
- loopmath/skill/{skills/loopmath-onboard/SKILL.md → guides/onboard.md} +2 -8
- loopmath/skill/{skills/loopmath-plan-task/SKILL.md → guides/plan.md} +3 -9
- loopmath/skill/{skills/loopmath-record-run/SKILL.md → guides/record.md} +2 -8
- loopmath/skill/{skills → guides}/reference.md +2 -2
- loopmath/skill/install.py +144 -71
- loopmath/skill/skills/loopmath/SKILL.md +45 -23
- {loopmath-0.3.2.dist-info → loopmath-0.3.4.dist-info}/METADATA +15 -14
- {loopmath-0.3.2.dist-info → loopmath-0.3.4.dist-info}/RECORD +24 -23
- {loopmath-0.3.2.dist-info → loopmath-0.3.4.dist-info}/licenses/LICENSE +1 -1
- {loopmath-0.3.2.data → loopmath-0.3.4.data}/data/spec/ocp-v0.2.schema.json +0 -0
- {loopmath-0.3.2.data → loopmath-0.3.4.data}/data/spec/ocp-v0.schema.json +0 -0
- {loopmath-0.3.2.data → loopmath-0.3.4.data}/data/spec/ocp_conformance.py +0 -0
- {loopmath-0.3.2.dist-info → loopmath-0.3.4.dist-info}/WHEEL +0 -0
- {loopmath-0.3.2.dist-info → loopmath-0.3.4.dist-info}/entry_points.txt +0 -0
- {loopmath-0.3.2.dist-info → loopmath-0.3.4.dist-info}/top_level.txt +0 -0
loopmath/__init__.py
CHANGED
loopmath/cli.py
CHANGED
|
@@ -14,7 +14,7 @@ Verbs:
|
|
|
14
14
|
plan: task-types workflows recommend builder plan
|
|
15
15
|
record: run start|record|import|attempt|artifact|finish|sessions outcome budget config
|
|
16
16
|
learn: fit onboard share
|
|
17
|
-
view: runs posterior status report doctor skill ocp
|
|
17
|
+
view: runs posterior status report doctor guide skill ocp
|
|
18
18
|
|
|
19
19
|
No verb in this CLI connects to another machine; builder serves on 127.0.0.1 only.
|
|
20
20
|
Verbs write only to the store ($LOOPMATH_HOME, default ~/.loopmath, which also
|
loopmath/cli_registry.py
CHANGED
|
@@ -633,9 +633,16 @@ def _add_viewing(sub) -> None:
|
|
|
633
633
|
_common(p)
|
|
634
634
|
p.set_defaults(func=_lazy("loopmath.skill.commands:doctor"))
|
|
635
635
|
|
|
636
|
-
p = sub.add_parser("
|
|
636
|
+
p = sub.add_parser("guide", help="print the instructions for one job (onboard, import, plan, record, fit) or "
|
|
637
|
+
"the command reference, for an agent to follow; read only")
|
|
638
|
+
p.add_argument("topic", nargs="?", default=None, metavar="TOPIC",
|
|
639
|
+
help="onboard, import, plan, record, fit or reference (default: list them, with when to use each)")
|
|
640
|
+
p.set_defaults(func=_lazy("loopmath.skill.guide:command"))
|
|
641
|
+
|
|
642
|
+
p = sub.add_parser("skill", help="install, remove or print the loopmath skill")
|
|
637
643
|
ss = p.add_subparsers(dest="skill_command", required=True)
|
|
638
|
-
for verb, helptext in (("install", "write the
|
|
644
|
+
for verb, helptext in (("install", "write the loopmath skill for Claude Code, Codex or both, and remove the job "
|
|
645
|
+
"skills 0.3.3 and older installed"),
|
|
639
646
|
("uninstall", "remove what install wrote")):
|
|
640
647
|
q = ss.add_parser(verb, help=helptext)
|
|
641
648
|
q.add_argument("--target", default="auto", choices=["auto", "claude-code", "codex", "both"],
|
|
@@ -645,14 +652,12 @@ def _add_viewing(sub) -> None:
|
|
|
645
652
|
q.add_argument("--dir", default=None, metavar="PATH", help="the project folder for --scope project "
|
|
646
653
|
"(default: this folder)")
|
|
647
654
|
if verb == "install":
|
|
648
|
-
q.add_argument("--dry-run", action="store_true", help="print every file install would write
|
|
649
|
-
"
|
|
655
|
+
q.add_argument("--dry-run", action="store_true", help="print every file install would write, change "
|
|
656
|
+
"or remove, and write nothing")
|
|
650
657
|
_common(q)
|
|
651
658
|
q.set_defaults(func=_lazy(f"loopmath.skill.commands:{verb}"))
|
|
652
|
-
q = ss.add_parser("show", help="print
|
|
653
|
-
q.add_argument("name", nargs="?", default="loopmath", metavar="NAME",
|
|
654
|
-
help="loopmath, loopmath-onboard, loopmath-import-runs, loopmath-update-fit, loopmath-plan-task, "
|
|
655
|
-
"loopmath-record-run, or reference")
|
|
659
|
+
q = ss.add_parser("show", help="print the loopmath skill (the job guides are `loopmath guide`)")
|
|
660
|
+
q.add_argument("name", nargs="?", default="loopmath", metavar="NAME", help="loopmath, the one skill")
|
|
656
661
|
q.set_defaults(func=_lazy("loopmath.skill.commands:show"))
|
|
657
662
|
|
|
658
663
|
p = sub.add_parser("ocp", help="validate or migrate OCP documents")
|
loopmath/onboard/commands.py
CHANGED
|
@@ -127,7 +127,7 @@ def onboard(args: argparse.Namespace) -> int:
|
|
|
127
127
|
print(f"onboard: reading Claude Code and Codex history, {_window_words(since)}"
|
|
128
128
|
+ ("" if H.parse_cache().is_file() else "; a large history can take several minutes on the first read"),
|
|
129
129
|
file=sys.stderr, flush=True)
|
|
130
|
-
# Then, also when captured, what the answers start from, once (the
|
|
130
|
+
# Then, also when captured, what the answers start from, once (the onboard guide shows this line to the user).
|
|
131
131
|
prior = starting_prior()
|
|
132
132
|
print(prior["line"], file=sys.stderr, flush=True)
|
|
133
133
|
hist = deps.load_history(since_days, logs=deps.logs, progress=_progress, stage=_stage)
|
loopmath/skill/commands.py
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
"""Handlers for `loopmath doctor` and `loopmath skill install|uninstall|show`.
|
|
2
|
+
(`loopmath guide` is guide.py's, which imports nothing else.)
|
|
2
3
|
"""
|
|
3
4
|
|
|
4
5
|
from __future__ import annotations
|
|
@@ -36,16 +37,9 @@ _WOULD = {"created": "to write", "updated": "to update", "replaced": "to replace
|
|
|
36
37
|
"removed": "to remove", "unchanged": "unchanged", "kept": "kept"}
|
|
37
38
|
|
|
38
39
|
|
|
39
|
-
def _count(entries: list[dict], dry_run: bool = False) -> str:
|
|
40
|
-
counts: dict[str, int] = {}
|
|
41
|
-
for e in entries:
|
|
42
|
-
counts[e["action"]] = counts.get(e["action"], 0) + 1
|
|
43
|
-
return ", ".join(f"{n} {_WOULD[action] if dry_run else action}" for action, n in counts.items())
|
|
44
|
-
|
|
45
|
-
|
|
46
40
|
def _results(verb: str, results: list[dict], as_json: bool) -> None:
|
|
47
41
|
if as_json:
|
|
48
|
-
emit_json("loopmath.skill/
|
|
42
|
+
emit_json("loopmath.skill/3", {"verb": verb, "results": results})
|
|
49
43
|
return
|
|
50
44
|
dry = any(r.get("dry_run") for r in results)
|
|
51
45
|
if dry:
|
|
@@ -53,19 +47,20 @@ def _results(verb: str, results: list[dict], as_json: bool) -> None:
|
|
|
53
47
|
for r in results:
|
|
54
48
|
form = " (AGENTS.md block)" if r["method"] == "agents_block" else ""
|
|
55
49
|
head = f"{r['target']} {r['scope']}{form}"
|
|
56
|
-
|
|
57
|
-
if verb == "uninstall" and
|
|
50
|
+
[skill] = r["skills"]
|
|
51
|
+
if verb == "uninstall" and skill["action"] == "absent" and not r["removed"]:
|
|
58
52
|
print(f"{head}: not installed in {r['root']}, nothing to remove")
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
if dry:
|
|
65
|
-
print(f"
|
|
66
|
-
f"and {r['manifest']}, the list of the files install wrote")
|
|
53
|
+
continue
|
|
54
|
+
print(f"{head}:")
|
|
55
|
+
if skill["action"] != "absent":
|
|
56
|
+
print(f" {_WOULD[skill['action']] if dry else skill['action']} {skill['path']}, the loopmath skill")
|
|
57
|
+
action = r.get("manifest_action")
|
|
58
|
+
if dry and action:
|
|
59
|
+
print(f" {_WOULD[action]} {r['manifest']}, the list of the files install wrote")
|
|
67
60
|
for e in r["removed"]:
|
|
68
61
|
print(f" {'to remove' if dry else 'removed'} {e['path']}")
|
|
62
|
+
if any(e["path"].endswith(f"/{name}/SKILL.md") for e in r["removed"] for name in _install.RETIRED_SKILLS):
|
|
63
|
+
print(" (0.3.4 installs one skill; the job skills' text comes from `loopmath guide` now)")
|
|
69
64
|
block, where = r.get("block"), r.get("block_file") or r.get("agents_md")
|
|
70
65
|
if block == "removed":
|
|
71
66
|
print(f" {'to remove' if dry else 'removed'} the loopmath block from {where}")
|
|
@@ -104,5 +99,8 @@ def show(args: argparse.Namespace) -> int:
|
|
|
104
99
|
try:
|
|
105
100
|
sys.stdout.write(_install.skill_text(name))
|
|
106
101
|
except KeyError:
|
|
107
|
-
|
|
102
|
+
topic = "reference" if name == "reference" else _install.RETIRED_SKILLS.get(name)
|
|
103
|
+
if topic:
|
|
104
|
+
return fail(f"0.3.4 has one skill, loopmath; {name} is `loopmath guide {topic}` now")
|
|
105
|
+
return fail(f"no skill {name!r}; the one skill is loopmath, and `loopmath guide` lists the job guides")
|
|
108
106
|
return EXIT_OK
|
loopmath/skill/doctor.py
CHANGED
|
@@ -6,7 +6,8 @@ Six checks, each `ok`, `warn` or `fail`:
|
|
|
6
6
|
store the store root exists and is writable
|
|
7
7
|
fit `fits/latest` present, and its age
|
|
8
8
|
prices every model seen in the scan window has a price
|
|
9
|
-
skill where the skill
|
|
9
|
+
skill where the loopmath skill is installed (and which Codex form), whether it is current, and the
|
|
10
|
+
job skills 0.3.3 and older installed that are still on disk
|
|
10
11
|
|
|
11
12
|
Nothing here opens a network connection. Log files are read through the
|
|
12
13
|
parse cache, which doctor keeps up to date in the store's cache folder (the
|
|
@@ -189,28 +190,51 @@ def _install_cmd(place: dict) -> str:
|
|
|
189
190
|
return f"loopmath skill install --target {place['target']} --scope {place['scope']}"
|
|
190
191
|
|
|
191
192
|
|
|
193
|
+
def _folders(paths: list[str]) -> str:
|
|
194
|
+
"""The retired files, by the skill folder each is in (`loopmath/reference.md` by its name)."""
|
|
195
|
+
names = []
|
|
196
|
+
for path in paths:
|
|
197
|
+
folder, file = Path(path).parent.name, Path(path).name
|
|
198
|
+
name = f"{folder}/{file}" if folder == "loopmath" else folder
|
|
199
|
+
if name not in names:
|
|
200
|
+
names.append(name)
|
|
201
|
+
return ", ".join(names)
|
|
202
|
+
|
|
203
|
+
|
|
192
204
|
def check_skill(cwd: Path | None, env: Mapping[str, str] | None) -> dict:
|
|
193
|
-
"""`ok` when the
|
|
194
|
-
left anywhere; else a warning with the exact install command.
|
|
205
|
+
"""`ok` when the skill is installed and current for some target, with nothing old, partial or
|
|
206
|
+
retired left anywhere; else a warning with the exact install command. Retired files loopmath still
|
|
207
|
+
owns go with that command; the others were kept, and the warning says why."""
|
|
195
208
|
places = _install.status(cwd=cwd, env=env)
|
|
196
|
-
n = len(_install.SKILLS)
|
|
197
209
|
seen = [p for p in places if p["any"]]
|
|
198
210
|
if not seen:
|
|
199
211
|
return _check("skill", "warn", "not installed: run `loopmath skill install`", places=places)
|
|
200
212
|
problems = []
|
|
201
213
|
for p in seen:
|
|
202
214
|
where = f"{p['target']} {p['scope']}"
|
|
215
|
+
retired = p["retired"]
|
|
203
216
|
if p["old"]:
|
|
204
217
|
problems.append(f"{where} still has the 0.1 single skill: run `{_install_cmd(p)}`")
|
|
205
218
|
elif p["missing"]:
|
|
206
|
-
problems.append(f"{where} lacks
|
|
219
|
+
problems.append(f"{where} lacks the loopmath skill: run `{_install_cmd(p)}`")
|
|
207
220
|
elif not p["current"]:
|
|
208
221
|
problems.append(f"{where} is older than this loopmath: run `{_install_cmd(p)}`")
|
|
222
|
+
if retired["owned"]:
|
|
223
|
+
problems.append(f"{where} still has the job skills 0.3.3 and older installed "
|
|
224
|
+
f"({_folders(retired['owned'])}): run `{_install_cmd(p)}` to remove them")
|
|
225
|
+
if retired["changed"]:
|
|
226
|
+
problems.append(f"{where} kept {', '.join(retired['changed'])}: changed since loopmath wrote "
|
|
227
|
+
f"{'them' if len(retired['changed']) > 1 else 'it'}; move "
|
|
228
|
+
f"{'them' if len(retired['changed']) > 1 else 'it'} aside when no longer needed")
|
|
229
|
+
if retired["foreign"]:
|
|
230
|
+
problems.append(f"{where} has {', '.join(retired['foreign'])}, where 0.3.3 and older put job skills, "
|
|
231
|
+
"but loopmath did not write "
|
|
232
|
+
f"{'them' if len(retired['foreign']) > 1 else 'it'}: left alone")
|
|
209
233
|
if problems:
|
|
210
234
|
return _check("skill", "warn", "; ".join(problems), places=places)
|
|
211
235
|
parts = [f"{p['target']} {p['scope']} ({'AGENTS.md block' if p['method'] == 'agents_block' else 'skills'})"
|
|
212
236
|
for p in seen]
|
|
213
|
-
return _check("skill", "ok",
|
|
237
|
+
return _check("skill", "ok", "the loopmath skill: " + ", ".join(parts), places=places)
|
|
214
238
|
|
|
215
239
|
|
|
216
240
|
def run_checks(home: Path, *, env: Mapping[str, str] | None = None, cwd: Path | None = None,
|
loopmath/skill/guide.py
ADDED
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
"""`loopmath guide [TOPIC]`: the instructions for each job, for the agent to read and follow.
|
|
2
|
+
|
|
3
|
+
The one installed skill (`skills/loopmath/SKILL.md`) sends the agent here, so a job's
|
|
4
|
+
instructions always match the installed loopmath. Each topic is a packaged file in `guides/`:
|
|
5
|
+
the five jobs, then the command reference they share. Read only: it needs no store and writes
|
|
6
|
+
nothing, so this module imports nothing from the rest of loopmath.
|
|
7
|
+
"""
|
|
8
|
+
|
|
9
|
+
from __future__ import annotations
|
|
10
|
+
|
|
11
|
+
import argparse
|
|
12
|
+
import sys
|
|
13
|
+
from importlib import resources
|
|
14
|
+
|
|
15
|
+
# Each topic, with one line on when to use it, in the order `loopmath guide` lists them.
|
|
16
|
+
TOPICS = {
|
|
17
|
+
"onboard": "set up, start or try loopmath from the user's Claude Code and Codex history, or loopmath has no runs yet",
|
|
18
|
+
"import": "OCP files or a folder of finished runs to bring into loopmath",
|
|
19
|
+
"plan": "a task to do: pick its workflow, models and effort, then start the run",
|
|
20
|
+
"record": "a task is done: record the run and show its receipt, or judge a pair blind",
|
|
21
|
+
"fit": "update the fit, say what loopmath learned, or the fit is not usable",
|
|
22
|
+
"reference": "every command, flag, JSON field and exit code the guides use",
|
|
23
|
+
}
|
|
24
|
+
FOLLOW = "Run `loopmath guide <topic>` and follow it."
|
|
25
|
+
EXIT_UNKNOWN = 2 # the CLI's "not found"
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
def text(topic: str) -> str:
|
|
29
|
+
"""One topic's text, as packaged. KeyError on another name."""
|
|
30
|
+
if topic not in TOPICS:
|
|
31
|
+
raise KeyError(topic)
|
|
32
|
+
return resources.files("loopmath.skill").joinpath("guides", f"{topic}.md").read_text(encoding="utf-8")
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
def listing() -> str:
|
|
36
|
+
"""What `loopmath guide` alone prints: each topic with when to use it, then how to read one."""
|
|
37
|
+
width = max(map(len, TOPICS))
|
|
38
|
+
rows = [f" {name:<{width}} {when}" for name, when in TOPICS.items()]
|
|
39
|
+
return "loopmath guides, one per job, and the command reference:\n\n" + "\n".join(rows) + f"\n\n{FOLLOW}\n"
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def command(args: argparse.Namespace) -> int:
|
|
43
|
+
topic = getattr(args, "topic", None)
|
|
44
|
+
if topic is None:
|
|
45
|
+
sys.stdout.write(listing())
|
|
46
|
+
return 0
|
|
47
|
+
try:
|
|
48
|
+
sys.stdout.write(text(topic))
|
|
49
|
+
except KeyError:
|
|
50
|
+
print(f"error: no guide {topic!r}; the topics are {', '.join(TOPICS)}. {FOLLOW}", file=sys.stderr)
|
|
51
|
+
return EXIT_UNKNOWN
|
|
52
|
+
return 0
|
|
@@ -1,14 +1,8 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: loopmath-update-fit
|
|
3
|
-
description: "Refit loopmath on every run recorded so far and show the results page. Use when the user asks to update, refresh or rerun the loopmath fit, asks what loopmath learned or believes about models, efforts or workflows, or after runs were imported or recorded without a refit."
|
|
4
|
-
allowed-tools: Bash(loopmath:*), Bash(open:*), Bash(xdg-open:*)
|
|
5
|
-
---
|
|
6
|
-
|
|
7
1
|
# Update the loopmath fit
|
|
8
2
|
|
|
9
3
|
Refit on everything in the store, then show the results page. No question.
|
|
10
4
|
|
|
11
|
-
Use exactly the commands below. Flags and fields are in `
|
|
5
|
+
Use exactly the commands below. Flags and fields are in `loopmath guide reference`. Never run `--help`.
|
|
12
6
|
|
|
13
7
|
## 1. Fit
|
|
14
8
|
|
|
@@ -24,7 +18,7 @@ A new fit replaces the one `recommend` and the pages read. Read `fit.id`, `fit.n
|
|
|
24
18
|
|
|
25
19
|
`shipped_overlap` counts, per shipped source, the user's runs that the shipped prior also holds (the same runs); the fit uses the user's copies. When it has counts, the summary says one line, once: "N of your runs are also in the shipped SOURCE prior (same runs): fits use your copies", with the total for N ("1 of your runs is also in the shipped SOURCE prior (same run): fits use your copy" for one run), and with several sources "the shipped prior (rq1 40, e0 4)" for "the shipped SOURCE prior". Its `dropped` reason, "shipped copy of a stored run", is that same overlap: do not name it again.
|
|
26
20
|
|
|
27
|
-
If it exits 4 (another fit holds the lock), wait 30 seconds and run it once more. If `fit.n_runs.user` is 0 and the user expected runs, say so and suggest `loopmath
|
|
21
|
+
If it exits 4 (another fit holds the lock), wait 30 seconds and run it once more. If `fit.n_runs.user` is 0 and the user expected runs, say so and suggest onboarding (`loopmath guide onboard`) or bringing existing runs (`loopmath guide import`).
|
|
28
22
|
|
|
29
23
|
## 2. Show the results page
|
|
30
24
|
|
|
@@ -1,14 +1,8 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: loopmath-import-runs
|
|
3
|
-
description: "Bring agent runs the user already has as OCP files (*.ocp.json) into loopmath in one pass: validate all, import all, fit once, show the results page. Use when the user points at OCP files or a folder of finished runs, or at the output of an orchestrator or experiment harness that writes OCP, and wants loopmath to learn from them."
|
|
4
|
-
allowed-tools: Bash(loopmath:*), Bash(open:*), Bash(xdg-open:*)
|
|
5
|
-
---
|
|
6
|
-
|
|
7
1
|
# Bring existing runs into loopmath
|
|
8
2
|
|
|
9
3
|
The user has finished runs written as OCP v0.3 (or v0.1, v0.2) documents. Validate them all, import them all without refitting after each, fit once, and show the results page. Ask nothing unless the location of the files is unknown.
|
|
10
4
|
|
|
11
|
-
Use exactly the commands below. Flags and fields are in `
|
|
5
|
+
Use exactly the commands below. Flags and fields are in `loopmath guide reference`. Never run `--help`.
|
|
12
6
|
|
|
13
7
|
## 1. Find the files
|
|
14
8
|
|
|
@@ -1,14 +1,8 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: loopmath-onboard
|
|
3
|
-
description: "Set the user up with loopmath from their own Claude Code and Codex history, in one pass: one question (which model labels their sessions, with its cost), then onboarding, the first fit and the results page. Use when the user asks to onboard, set up, start or try loopmath, or when loopmath has no runs yet."
|
|
4
|
-
allowed-tools: Bash(loopmath:*), Bash(open:*), Bash(xdg-open:*)
|
|
5
|
-
---
|
|
6
|
-
|
|
7
1
|
# Onboard the user with loopmath
|
|
8
2
|
|
|
9
3
|
Onboarding reads the user's past Claude Code and Codex sessions (read only), groups them into tasks, has a model the user chooses name each task's type, records one run per task, finds the usual workflow per task type and repo, and fits. You ask one question, the labeller with its cost, and do the rest without stopping.
|
|
10
4
|
|
|
11
|
-
Use exactly the commands below. Flags and fields are in `
|
|
5
|
+
Use exactly the commands below. Flags and fields are in `loopmath guide reference`. Never run `--help`.
|
|
12
6
|
|
|
13
7
|
## 1. Look first (no question yet)
|
|
14
8
|
|
|
@@ -22,7 +16,7 @@ Read `prior.line`, `groups.total`, `groups.to_label`, `window.from`, `window.to`
|
|
|
22
16
|
|
|
23
17
|
Show the user `prior.line` once, word for word. It says what the answers start from before any of their runs, the prior that ships inside loopmath: its version, its runs per source, the published benchmarks it holds and the date it was built. Do not repeat it later, and do not write the numbers yourself: they change with each release. `loopmath prior show` lists the same prior source by source.
|
|
24
18
|
|
|
25
|
-
If `groups.to_label` is 0, there is nothing to label. Do not ask anything. Say what was found (`groups.total` groups, none with a prompt to label, or no sessions in the window), run `loopmath fit --json`, and go to step 4.
|
|
19
|
+
If `groups.to_label` is 0, there is nothing to label. Do not ask anything. Say what was found (`groups.total` groups, none with a prompt to label, or no sessions in the window), run `loopmath fit --json`, and go to step 4. If the user has OCP files, offer to bring them in (`loopmath guide import`).
|
|
26
20
|
|
|
27
21
|
## 2. Ask one question
|
|
28
22
|
|
|
@@ -1,21 +1,15 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: loopmath-plan-task
|
|
3
|
-
description: "Choose the workflow, models and effort for one coding task with loopmath, then start it: recommend, show the ready choices with chance and cost, ask one question, open the run. Use when the user asks to plan a task or an implementation with loopmath, asks which workflow, model or effort to use, pastes an option from a loopmath planning page (option 2: ...), or starts a coding task of more than a few minutes of agent work in a repo where they use loopmath."
|
|
4
|
-
allowed-tools: Bash(loopmath:*), Bash(git rev-parse:*), Bash(git remote get-url:*), Bash(open:*), Bash(xdg-open:*)
|
|
5
|
-
---
|
|
6
|
-
|
|
7
1
|
# Plan a task with loopmath
|
|
8
2
|
|
|
9
3
|
One pass: classify the task, ask loopmath, show its choices, ask one question, start the chosen run, then do the work. The user makes one choice; you type everything else.
|
|
10
4
|
|
|
11
|
-
Use exactly the commands below. Flags and fields are in `
|
|
5
|
+
Use exactly the commands below. Flags and fields are in `loopmath guide reference`. Never run `--help`.
|
|
12
6
|
|
|
13
7
|
## 1. Classify the task (no question)
|
|
14
8
|
|
|
15
9
|
From the user's words and the repo, decide:
|
|
16
10
|
- `TYPE`: one of `bug_fix`, `feature`, `refactor`, `tests`, `docs`, `research`, `infra`, `data`;
|
|
17
11
|
- `TITLE`: the task in at most 60 characters;
|
|
18
|
-
- features you can tell: `size`, `lang`, `has_tests`, `spec_clarity`, `needs_design`, `touches` (values in `reference
|
|
12
|
+
- features you can tell: `size`, `lang`, `has_tests`, `spec_clarity`, `needs_design`, `touches` (values in `loopmath guide reference`). Leave out the rest;
|
|
19
13
|
- a target, only when the user states a score or runtime goal: `--target 'heldout_perf>=2400'`.
|
|
20
14
|
|
|
21
15
|
Then the repo and the base commit. When the user names the repo ("in ale-bench", "for acme/api"), `REPO` is that name, lowercased. In the folder you work in:
|
|
@@ -111,7 +105,7 @@ Run the pieces in order, each with its setting from `piece_settings`. Note every
|
|
|
111
105
|
- **Width above 1:** launch that many agents for the piece, each with its own session.
|
|
112
106
|
- **Pair:** both runs start from `SHA` in separate git worktrees (`git worktree add ../TASK-a SHA`, `../TASK-b SHA`; with no git checkout, two copies of the folder), and both finish before any judging.
|
|
113
107
|
|
|
114
|
-
When the work is done,
|
|
108
|
+
When the work is done, run `loopmath guide record` and follow it.
|
|
115
109
|
|
|
116
110
|
## Never
|
|
117
111
|
|
|
@@ -1,14 +1,8 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: loopmath-record-run
|
|
3
|
-
description: "Record a finished agent run in loopmath with one command, from the session ids noted while the work ran, with test results and scores, then show the receipt: predicted against actual cost, and the outcome. Use when a task planned with loopmath is done, when the user asks to record, log or save a run in loopmath, or when both runs of a loopmath pair are done and need a blind judge."
|
|
4
|
-
allowed-tools: Bash(loopmath:*), Bash(open:*), Bash(xdg-open:*)
|
|
5
|
-
---
|
|
6
|
-
|
|
7
1
|
# Record a run with loopmath
|
|
8
2
|
|
|
9
3
|
One command records the whole run: one attempt per session (a Claude Code session counts its sub-agents), the commits made since the base commit, the verdicts and scores, the cost from the logs, the receipt and a background refit. Ask nothing unless you cannot tell which sessions did the work.
|
|
10
4
|
|
|
11
|
-
Use exactly the commands below, and read their JSON as printed. Flags and fields are in `
|
|
5
|
+
Use exactly the commands below, and read their JSON as printed. Flags and fields are in `loopmath guide reference`. Never run `--help`.
|
|
12
6
|
|
|
13
7
|
## 1. Gather what the command needs (no question)
|
|
14
8
|
|
|
@@ -56,7 +50,7 @@ The second line is `receipt.line`. Report every `unmatched` entry and every note
|
|
|
56
50
|
|
|
57
51
|
## 4. Pairs: judge blind, after both runs are recorded
|
|
58
52
|
|
|
59
|
-
When the run belongs to a slate (a pair
|
|
53
|
+
When the run belongs to a slate (a pair started as `loopmath guide plan` says) and both runs are recorded:
|
|
60
54
|
|
|
61
55
|
1. `loopmath config get referee.model --json`: launch a fresh agent of that family (a family other than both runs' implementers when `value` is null).
|
|
62
56
|
2. Give it the task and the two diffs in random order as A and B, without run ids, workflow names or models, with this prompt:
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
# loopmath reference for agents
|
|
2
2
|
|
|
3
|
-
Shared by every loopmath
|
|
3
|
+
Shared by every loopmath guide; `loopmath guide reference` prints it. Every command, flag and JSON field the guides use is here. Never run loopmath or any of its commands with `--help`: if something is missing here, run `loopmath doctor --json` and tell the user.
|
|
4
4
|
|
|
5
5
|
## Conventions
|
|
6
6
|
|
|
@@ -70,7 +70,7 @@ loopmath recommend --type TYPE --repo REPO --title "TEXT" --feature size=m --bas
|
|
|
70
70
|
- Up to 5 choices. Their order in `choices[]` is the order to number them in: each has `option`, its number from 1, the same number the planning page shows. The page's "Copy option" button copies `option N: LABEL`; a user who pastes it means the choice with that `label`; when no choice has that label (a page from another recommendation), show the current choices and ask, and never start another workflow in its place. For a row that is not a numbered option it copies `workflow CFG: LABEL`: start that configuration with `--config CFG` (Run start, below).
|
|
71
71
|
- `most_likely` (with a score target): the workflow with the highest chance to reach the target. Left out when it is already another choice.
|
|
72
72
|
- `p_accepted_within` on each choice (and in each `numbers` object): `mean`, `lo`, `hi`, `attempts`: the chance of an accepted result within `attempts` attempts, the first run and its retries (a ceiling: retries have less and less chance). Show it apart from `chance`, the chance of one run.
|
|
73
|
-
- `bands` on each choice (and in each `numbers` object) in the full `--json`, the stored recommendation and the page data, not in `--brief`: central intervals, `chance`, `run_cost_usd` and `cost_per_accepted_usd`, each `{"50": [lo, hi], "80": [...], "90": [...], "95": [...]}`; a missing level is an absent key. For the pages; the
|
|
73
|
+
- `bands` on each choice (and in each `numbers` object) in the full `--json`, the stored recommendation and the page data, not in `--brief`: central intervals, `chance`, `run_cost_usd` and `cost_per_accepted_usd`, each `{"50": [lo, hi], "80": [...], "90": [...], "95": [...]}`; a missing level is an absent key. For the pages; the guides show the 80% range from `lo` and `hi`.
|
|
74
74
|
- There is a `pair` choice only when a second workflow is worth trying beside the goal; without one, `message` says so, and `run start --choice` takes only the keys in `choices[]`. The `pair` choice adds `explore_config` (the second member), `price_now_usd` (the extra run's cost now), `gain_per_future_run_usd` (the expected saving on each future similar run), `payback_runs` (similar runs until the extra run pays for itself: `price_now_usd` divided by `gain_per_future_run_usd`, rounded up, at least 1; null when the gain is 0; the number `message` says) and `p_beats_goal`.
|
|
75
75
|
- `rescue`: how a missed run is fixed, which cost per accepted result counts. `kind` `retry` (the default): retry with another workflow, `of` (its label) and `config` (its id), chosen as the cheapest per run with at least `min_chance` (0.7) chance, else the most likely; `chance` (`mean`, `lo`, `hi`) and `run_cost_usd` are its own; each extra attempt has `decay` (0.5) times the chance of the one before, up to `max_attempts` (3) attempts in all, counting the first run; `p_accepted` is the chance the retries fix a miss; `usd` and `tokens` are the expected cost of fixing a miss; `basis` says how it was chosen; `text` is one plain sentence about it: quote it word for word. Older kinds: `redo_usual` (the reference repeated until accepted), `person` (a person's time), `none`. Without `text`, run cost is what the agents cost for one run, and cost per accepted result adds `expected_rescue_usd`, the expected cost of fixing a miss.
|
|
76
76
|
- The `goal` choice adds `strategy`: null, or the try-then-rescue plan when the pick is less likely than the reference. Show `strategy.text` word for word. Its numbers are in `chance`, `misses`, `rescue`, `cost_per_accepted_usd` and `reference_cost_per_accepted_usd`. The same object is `goal.strategy`.
|
loopmath/skill/install.py
CHANGED
|
@@ -1,30 +1,33 @@
|
|
|
1
|
-
"""Install the skill
|
|
1
|
+
"""Install the loopmath skill for Claude Code and Codex, user and project scope (spec 07, section 1).
|
|
2
2
|
|
|
3
|
-
|
|
4
|
-
`
|
|
3
|
+
One skill, `loopmath` (`SKILLS`), a folder with its `SKILL.md`; the instructions for each job
|
|
4
|
+
come from `loopmath guide` (guide.py), so they match the installed version:
|
|
5
5
|
|
|
6
|
-
| target | scope | where
|
|
6
|
+
| target | scope | where the skill folder goes |
|
|
7
7
|
|-------------|---------|---------------------------------------------------------------|
|
|
8
|
-
| claude-code | user | ~/.claude/skills
|
|
9
|
-
| claude-code | project | .claude/skills
|
|
10
|
-
| codex | user | ~/.codex/skills
|
|
11
|
-
| | | ~/.codex/loopmath
|
|
12
|
-
| | | ~/.codex/AGENTS.md
|
|
13
|
-
| codex | project | .codex/skills
|
|
8
|
+
| claude-code | user | ~/.claude/skills/loopmath/ ($CLAUDE_CONFIG_DIR wins) |
|
|
9
|
+
| claude-code | project | .claude/skills/loopmath/ |
|
|
10
|
+
| codex | user | ~/.codex/skills/loopmath/ ($CODEX_HOME wins), or |
|
|
11
|
+
| | | ~/.codex/loopmath/loopmath/ and a marked block in |
|
|
12
|
+
| | | ~/.codex/AGENTS.md naming it |
|
|
13
|
+
| codex | project | .codex/skills/loopmath/, or .codex/loopmath/loopmath/ and the |
|
|
14
14
|
| | | block in AGENTS.md |
|
|
15
15
|
|
|
16
|
-
Codex gets skill
|
|
17
|
-
folder existing (Codex creates it); otherwise the pointer block. The packaged
|
|
16
|
+
Codex gets the skill folder when it supports skills, which we read from the user's Codex skills
|
|
17
|
+
folder existing (Codex creates it); otherwise the pointer block. The packaged source carries
|
|
18
18
|
Claude Code's frontmatter; Codex gets the same text without `allowed-tools`.
|
|
19
19
|
|
|
20
20
|
Ownership is by manifest, never by a path alone. Install writes `.loopmath-skills.json` in the
|
|
21
21
|
folder that holds the skill folders, with the sha256 of every file it wrote. Install, upgrade and
|
|
22
|
-
uninstall
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
22
|
+
uninstall write only the skill's file (`OWNED`), and only when the manifest lists it with its
|
|
23
|
+
current hash, or it already holds exactly what install would write. A listed file the user has
|
|
24
|
+
changed is kept, with a note. Any other file in the way stops the whole install before its first
|
|
25
|
+
write. 0.2.0 to 0.3.3 installed six skills, each with a copy of a shared `reference.md`; install
|
|
26
|
+
and uninstall remove those eleven files (`RETIRED`) only where the manifest lists them with their
|
|
27
|
+
current hash, and keep the rest with a note. The 0.1 single skill (`loopmath/SKILL.md`, and for
|
|
28
|
+
Codex without skills `loopmath/SKILL.md` beside the block) is replaced or removed only when its
|
|
29
|
+
hash is one loopmath 0.1 shipped (`LEGACY_SHA256`). In AGENTS.md only the text between the
|
|
30
|
+
markers changes.
|
|
28
31
|
"""
|
|
29
32
|
|
|
30
33
|
from __future__ import annotations
|
|
@@ -39,17 +42,11 @@ from importlib import resources
|
|
|
39
42
|
from pathlib import Path
|
|
40
43
|
from typing import Mapping
|
|
41
44
|
|
|
42
|
-
SKILLS = ("loopmath",
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
"loopmath-import-runs": "bring existing OCP files or a folder of finished runs into loopmath",
|
|
48
|
-
"loopmath-update-fit": "update the fit, or say what loopmath learned",
|
|
49
|
-
"loopmath-plan-task": "plan a coding task: which workflow, model or effort, then start the run",
|
|
50
|
-
"loopmath-record-run": "record a finished run, show its receipt, judge a pair",
|
|
51
|
-
}
|
|
52
|
-
REFERENCE = "reference.md"
|
|
45
|
+
SKILLS = ("loopmath",)
|
|
46
|
+
# The job skills 0.2.0 to 0.3.3 installed beside `loopmath`, and the `loopmath guide` topic that has each one's text now.
|
|
47
|
+
RETIRED_SKILLS = {"loopmath-onboard": "onboard", "loopmath-import-runs": "import", "loopmath-update-fit": "fit",
|
|
48
|
+
"loopmath-plan-task": "plan", "loopmath-record-run": "record"}
|
|
49
|
+
REFERENCE = "reference.md" # each of the six skill folders had a copy; now `loopmath guide reference`
|
|
53
50
|
TARGETS = ("claude-code", "codex")
|
|
54
51
|
TARGET_CHOICES = ("auto", "claude-code", "codex", "both")
|
|
55
52
|
SCOPES = ("user", "project")
|
|
@@ -57,8 +54,9 @@ BLOCK_BEGIN = "<!-- loopmath -->"
|
|
|
57
54
|
BLOCK_END = "<!-- /loopmath -->"
|
|
58
55
|
MANIFEST = ".loopmath-skills.json"
|
|
59
56
|
MANIFEST_SCHEMA = "loopmath.skill.manifest/1"
|
|
60
|
-
OWNED = tuple(f"{name}/
|
|
61
|
-
|
|
57
|
+
OWNED = tuple(f"{name}/SKILL.md" for name in SKILLS) # the only files it writes
|
|
58
|
+
RETIRED = (f"loopmath/{REFERENCE}",) + tuple(f"{name}/{file}" for name in RETIRED_SKILLS for file in ("SKILL.md", REFERENCE))
|
|
59
|
+
LEGACY = "loopmath/SKILL.md" # where 0.1 put its single skill, and where the one skill goes now
|
|
62
60
|
# sha256 of the single SKILL.md loopmath 0.1 wrote, the same text for every target and form.
|
|
63
61
|
LEGACY_SHA256 = {
|
|
64
62
|
"164e47ba206b15a978c13858b1c1839c05f06afb3afb533786bb94e1433857e1": "0.1.0",
|
|
@@ -86,20 +84,22 @@ def _package_file(*parts: str) -> str:
|
|
|
86
84
|
return resources.files("loopmath.skill").joinpath("skills", *parts).read_text(encoding="utf-8")
|
|
87
85
|
|
|
88
86
|
|
|
89
|
-
def reference_text() -> str:
|
|
90
|
-
"""The shared reference, as packaged."""
|
|
91
|
-
return _package_file(REFERENCE)
|
|
92
|
-
|
|
93
|
-
|
|
94
87
|
def skill_text(name: str = "loopmath") -> str:
|
|
95
|
-
"""
|
|
96
|
-
if name == "reference":
|
|
97
|
-
return reference_text()
|
|
88
|
+
"""The packaged skill (Claude Code form). KeyError on another name."""
|
|
98
89
|
if name not in SKILLS:
|
|
99
90
|
raise KeyError(name)
|
|
100
91
|
return _package_file(name, "SKILL.md")
|
|
101
92
|
|
|
102
93
|
|
|
94
|
+
def description(text: str) -> str:
|
|
95
|
+
"""The `description` in a skill's frontmatter, unquoted."""
|
|
96
|
+
head = text.split("\n---\n", 1)[0] if text.startswith("---\n") else ""
|
|
97
|
+
for line in head.splitlines():
|
|
98
|
+
if line.startswith("description:"):
|
|
99
|
+
return line.partition(":")[2].strip().strip('"')
|
|
100
|
+
return ""
|
|
101
|
+
|
|
102
|
+
|
|
103
103
|
def _for_target(text: str, target: str) -> str:
|
|
104
104
|
"""Codex skills take `name` and `description` only: drop `allowed-tools` from the frontmatter."""
|
|
105
105
|
if target != "codex" or not text.startswith("---\n"):
|
|
@@ -178,10 +178,11 @@ def _block_path(where: Placement, path: Path, cwd: Path | None) -> str:
|
|
|
178
178
|
|
|
179
179
|
|
|
180
180
|
def pointer_block(where: Placement, cwd: Path | None = None) -> str:
|
|
181
|
+
"""The marked AGENTS.md block: one entry, the skill's own description and where its file is."""
|
|
182
|
+
when = description(skill_text("loopmath")).rstrip(".")
|
|
181
183
|
lines = [BLOCK_BEGIN, "## loopmath", "",
|
|
182
|
-
"loopmath has one skill
|
|
183
|
-
"
|
|
184
|
-
lines += [f"- {TRIGGERS[name]}: `{_block_path(where, where.skill_md(name), cwd)}`" for name in SKILLS]
|
|
184
|
+
"loopmath has one skill. Read it and follow it; `loopmath skill show` prints the same text.", "",
|
|
185
|
+
f"- {when}: `{_block_path(where, where.skill_md('loopmath'), cwd)}`"]
|
|
185
186
|
return "\n".join(lines) + f"\n{BLOCK_END}\n"
|
|
186
187
|
|
|
187
188
|
|
|
@@ -229,13 +230,8 @@ def _not_a_folder(path: Path) -> Path | None:
|
|
|
229
230
|
|
|
230
231
|
|
|
231
232
|
def _want(target: str) -> dict[str, str]:
|
|
232
|
-
"""Every file
|
|
233
|
-
|
|
234
|
-
want = {}
|
|
235
|
-
for skill, text in skill_texts(target).items():
|
|
236
|
-
want[f"{skill}/SKILL.md"] = text
|
|
237
|
-
want[f"{skill}/{REFERENCE}"] = reference
|
|
238
|
-
return want
|
|
233
|
+
"""Every file install writes for `target`, by its path under the folder that holds the skill folders."""
|
|
234
|
+
return {f"{skill}/SKILL.md": text for skill, text in skill_texts(target).items()}
|
|
239
235
|
|
|
240
236
|
|
|
241
237
|
def _load_manifest(root: Path) -> dict:
|
|
@@ -261,12 +257,40 @@ def _save_manifest(root: Path, manifest: dict) -> None:
|
|
|
261
257
|
path.unlink()
|
|
262
258
|
|
|
263
259
|
|
|
260
|
+
def _retired(where: Placement, listed: dict[str, str]) -> list[tuple[str, Path, str]]:
|
|
261
|
+
"""(path under root, path, how) for each retired file on disk in `where`: `owned` when the manifest
|
|
262
|
+
lists it with its current hash, so install and uninstall remove it; `changed` when listed with another
|
|
263
|
+
hash, and `foreign` when not listed, both kept."""
|
|
264
|
+
out = []
|
|
265
|
+
for rel in RETIRED:
|
|
266
|
+
path = where.root / rel
|
|
267
|
+
cur = _state(path)
|
|
268
|
+
if cur is None:
|
|
269
|
+
continue
|
|
270
|
+
how = "owned" if cur and listed.get(rel) == cur else ("changed" if rel in listed else "foreign")
|
|
271
|
+
out.append((rel, path, how))
|
|
272
|
+
return out
|
|
273
|
+
|
|
274
|
+
|
|
275
|
+
def guide_for(rel: str) -> str:
|
|
276
|
+
"""The `loopmath guide` topic that holds a retired file's text now."""
|
|
277
|
+
folder, _, file = rel.partition("/")
|
|
278
|
+
return "reference" if file == REFERENCE else RETIRED_SKILLS[folder]
|
|
279
|
+
|
|
280
|
+
|
|
281
|
+
def _retired_note(rel: str, path: Path, how: str) -> str:
|
|
282
|
+
why = "changed since loopmath wrote it" if how == "changed" else "loopmath did not write it"
|
|
283
|
+
return (f"kept {path}: {why}; 0.3.4 no longer installs it (`loopmath guide {guide_for(rel)}` has its text), "
|
|
284
|
+
"so move it aside when you no longer need it")
|
|
285
|
+
|
|
286
|
+
|
|
264
287
|
def _plan(where: Placement, want: dict[str, str]) -> tuple[dict, list[dict], list[str]]:
|
|
265
288
|
"""What install would do in `where`, before any write: (the manifest, one step per file, the paths
|
|
266
289
|
in the way). A file is loopmath's when the manifest lists it with its current hash, or when it
|
|
267
290
|
already holds exactly what install writes; the 0.1 single skill, when its hash is one 0.1 shipped.
|
|
268
291
|
A listed file with another hash was changed by someone and is kept. A file where a folder must be
|
|
269
|
-
(a skill folder, or one above it), and a folder or a dangling link at AGENTS.md, are in the way too.
|
|
292
|
+
(a skill folder, or one above it), and a folder or a dangling link at AGENTS.md, are in the way too.
|
|
293
|
+
The retired files are not in the way: they are removed or kept after the writes (`_retired`)."""
|
|
270
294
|
manifest = _load_manifest(where.root)
|
|
271
295
|
listed = manifest["files"]
|
|
272
296
|
steps, blocked = [], []
|
|
@@ -307,12 +331,11 @@ def _blocked(paths: list[str]) -> str:
|
|
|
307
331
|
|
|
308
332
|
|
|
309
333
|
def _entry(result: dict, rel: str, path: Path | str, action: str) -> None:
|
|
310
|
-
"""File one step under `skills
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
result["skills"].append({"name": skill, "path": str(path), "action": action})
|
|
334
|
+
"""File one step: the skill under `skills`, a retired file removed under `removed`."""
|
|
335
|
+
if rel in OWNED:
|
|
336
|
+
result["skills"].append({"name": rel.partition("/")[0], "path": str(path), "action": action})
|
|
337
|
+
elif action == "removed":
|
|
338
|
+
result["removed"].append({"path": str(path), "action": action})
|
|
316
339
|
|
|
317
340
|
|
|
318
341
|
# A file of the set with no manifest entry that already holds exactly the text install writes.
|
|
@@ -378,10 +401,16 @@ def _retire_legacy(path: Path, notes: list[str], dry_run: bool = False) -> str |
|
|
|
378
401
|
return "kept"
|
|
379
402
|
|
|
380
403
|
|
|
404
|
+
def _folders() -> list[str]:
|
|
405
|
+
"""Every skill folder the set and the retired files were in, in `OWNED` then `RETIRED` order."""
|
|
406
|
+
return list(dict.fromkeys(rel.partition("/")[0] for rel in OWNED + RETIRED))
|
|
407
|
+
|
|
408
|
+
|
|
381
409
|
def _remove_owned(where: Placement, notes: list[str], dry_run: bool = False) -> list[tuple[str, Path, str]]:
|
|
382
|
-
"""Remove
|
|
383
|
-
with a note. Returns (path under root, path,
|
|
384
|
-
the
|
|
410
|
+
"""Remove the skill in `where` when it is loopmath's (as `_plan` decides), and each retired file the
|
|
411
|
+
manifest lists with its current hash; keep the rest, with a note. Returns (path under root, path,
|
|
412
|
+
action) for the skill, and for each retired file on disk; the manifest keeps only the files that
|
|
413
|
+
stay. A dry run changes nothing and returns the same."""
|
|
385
414
|
manifest = _load_manifest(where.root)
|
|
386
415
|
listed = manifest["files"]
|
|
387
416
|
want = _want(where.target)
|
|
@@ -404,9 +433,21 @@ def _remove_owned(where: Placement, notes: list[str], dry_run: bool = False) ->
|
|
|
404
433
|
action = "kept"
|
|
405
434
|
notes.append(_kept(path, rel in listed))
|
|
406
435
|
out.append((rel, path, action))
|
|
436
|
+
for rel in RETIRED:
|
|
437
|
+
if _state(where.root / rel) is None:
|
|
438
|
+
listed.pop(rel, None)
|
|
439
|
+
for rel, path, how in _retired(where, listed):
|
|
440
|
+
if how == "owned":
|
|
441
|
+
if not dry_run:
|
|
442
|
+
path.unlink()
|
|
443
|
+
listed.pop(rel, None)
|
|
444
|
+
out.append((rel, path, "removed"))
|
|
445
|
+
else:
|
|
446
|
+
notes.append(_retired_note(rel, path, how))
|
|
447
|
+
out.append((rel, path, "kept"))
|
|
407
448
|
if dry_run:
|
|
408
449
|
return out
|
|
409
|
-
for skill in
|
|
450
|
+
for skill in _folders():
|
|
410
451
|
_rmdir_empty(where.root / skill)
|
|
411
452
|
_save_manifest(where.root, manifest)
|
|
412
453
|
return out
|
|
@@ -421,10 +462,20 @@ def _preflight(target: str, scope: str, cwd: Path | None, env: Mapping[str, str]
|
|
|
421
462
|
|
|
422
463
|
|
|
423
464
|
def _result(where: Placement) -> dict:
|
|
424
|
-
return {**where.to_dict(), "manifest": str(where.root / MANIFEST), "
|
|
465
|
+
return {**where.to_dict(), "manifest": str(where.root / MANIFEST), "manifest_action": None, "skills": [],
|
|
425
466
|
"removed": [], "block": None, "notes": []}
|
|
426
467
|
|
|
427
468
|
|
|
469
|
+
def _manifest_action(root: Path, before: dict[str, str], after: dict[str, str]) -> str:
|
|
470
|
+
"""What saving the manifest does to its file: created, updated, removed or unchanged."""
|
|
471
|
+
exists = (root / MANIFEST).is_file()
|
|
472
|
+
if not after:
|
|
473
|
+
return "removed" if exists else "unchanged"
|
|
474
|
+
if not exists:
|
|
475
|
+
return "created"
|
|
476
|
+
return "unchanged" if after == before else "updated"
|
|
477
|
+
|
|
478
|
+
|
|
428
479
|
def install(target: str = "auto", scope: str = "user", *, cwd: Path | None = None,
|
|
429
480
|
env: Mapping[str, str] | None = None, dry_run: bool = False) -> list[dict]:
|
|
430
481
|
"""Install the set for one target, `both` or `auto`. Returns one result per target. Every target is
|
|
@@ -446,6 +497,7 @@ def install(target: str = "auto", scope: str = "user", *, cwd: Path | None = Non
|
|
|
446
497
|
result = _result(where)
|
|
447
498
|
if dry_run:
|
|
448
499
|
result["dry_run"] = True
|
|
500
|
+
before = dict(manifest["files"])
|
|
449
501
|
for step in steps:
|
|
450
502
|
if step["action"] in ("created", "updated", "replaced") and not dry_run:
|
|
451
503
|
_write_atomic(step["path"], step["text"])
|
|
@@ -458,7 +510,21 @@ def install(target: str = "auto", scope: str = "user", *, cwd: Path | None = Non
|
|
|
458
510
|
result["notes"].append(_ADOPTED.format(path=step["path"], verb="would take" if dry_run else "took",
|
|
459
511
|
tense="holds"))
|
|
460
512
|
_entry(result, step["rel"], step["path"], step["action"])
|
|
513
|
+
for rel in RETIRED: # 0.2.0 to 0.3.3's job skills and reference copies: gone where loopmath still owns them
|
|
514
|
+
if _state(where.root / rel) is None:
|
|
515
|
+
manifest["files"].pop(rel, None)
|
|
516
|
+
for rel, path, how in _retired(where, manifest["files"]):
|
|
517
|
+
if how == "owned":
|
|
518
|
+
if not dry_run:
|
|
519
|
+
path.unlink()
|
|
520
|
+
manifest["files"].pop(rel, None)
|
|
521
|
+
_entry(result, rel, path, "removed")
|
|
522
|
+
else:
|
|
523
|
+
result["notes"].append(_retired_note(rel, path, how))
|
|
524
|
+
result["manifest_action"] = _manifest_action(where.root, before, manifest["files"])
|
|
461
525
|
if not dry_run:
|
|
526
|
+
for skill in _folders():
|
|
527
|
+
_rmdir_empty(where.root / skill)
|
|
462
528
|
_save_manifest(where.root, manifest)
|
|
463
529
|
if where.method == "agents_block":
|
|
464
530
|
if _retire_legacy(where.root / "SKILL.md", result["notes"], dry_run) == "removed":
|
|
@@ -534,9 +600,10 @@ def uninstall(target: str = "auto", scope: str = "user", *, cwd: Path | None = N
|
|
|
534
600
|
|
|
535
601
|
|
|
536
602
|
def status(*, cwd: Path | None = None, env: Mapping[str, str] | None = None) -> list[dict]:
|
|
537
|
-
"""Where the
|
|
603
|
+
"""Where the skill is installed, for `doctor`: one entry per target and scope. `retired` lists the
|
|
604
|
+
retired files still on disk there by how they stand (`_retired`), and with a broken manifest every
|
|
605
|
+
one of them as `foreign`."""
|
|
538
606
|
env = os.environ if env is None else env
|
|
539
|
-
reference = reference_text()
|
|
540
607
|
out = []
|
|
541
608
|
for name in TARGETS:
|
|
542
609
|
texts = skill_texts(name)
|
|
@@ -546,17 +613,23 @@ def status(*, cwd: Path | None = None, env: Mapping[str, str] | None = None) ->
|
|
|
546
613
|
block = True
|
|
547
614
|
if where.method == "agents_block":
|
|
548
615
|
try:
|
|
549
|
-
|
|
550
|
-
|
|
616
|
+
found = _split_block(where.agents_md.read_text(encoding="utf-8"))[1] \
|
|
617
|
+
if where.agents_md.is_file() else None
|
|
618
|
+
block = found == pointer_block(where, cwd)
|
|
551
619
|
except ValueError:
|
|
552
620
|
block = False
|
|
553
621
|
old = _state(where.root / LEGACY) in LEGACY_SHA256 or (where.method == "agents_block"
|
|
554
622
|
and _state(where.root / "SKILL.md") in LEGACY_SHA256)
|
|
555
|
-
current = all(where.skill_md(s).read_text(encoding="utf-8") == texts[s]
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
623
|
+
current = all(where.skill_md(s).read_text(encoding="utf-8") == texts[s] for s in present)
|
|
624
|
+
try:
|
|
625
|
+
listed = _load_manifest(where.root)["files"]
|
|
626
|
+
except ValueError:
|
|
627
|
+
listed = {}
|
|
628
|
+
retired: dict[str, list[str]] = {"owned": [], "changed": [], "foreign": []}
|
|
629
|
+
for _, path, how in _retired(where, listed):
|
|
630
|
+
retired[how].append(str(path))
|
|
559
631
|
out.append({**where.to_dict(), "installed": len(present) == len(SKILLS) and block,
|
|
560
|
-
"any": bool(present) or old
|
|
561
|
-
"
|
|
632
|
+
"any": bool(present) or old or any(retired.values()),
|
|
633
|
+
"missing": [s for s in SKILLS if s not in present],
|
|
634
|
+
"current": bool(present) and current and block, "old": old, "retired": retired})
|
|
562
635
|
return out
|
|
@@ -1,35 +1,57 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: loopmath
|
|
3
|
-
description:
|
|
4
|
-
allowed-tools: Bash(loopmath:*)
|
|
3
|
+
description: Use whenever the user mentions loopmath.
|
|
4
|
+
allowed-tools: Bash(loopmath:*), Bash(git rev-parse:*), Bash(git remote get-url:*), Bash(open:*), Bash(xdg-open:*)
|
|
5
5
|
---
|
|
6
6
|
|
|
7
|
-
# loopmath
|
|
7
|
+
# loopmath
|
|
8
8
|
|
|
9
|
-
|
|
9
|
+
## What loopmath is
|
|
10
10
|
|
|
11
|
-
|
|
11
|
+
loopmath is a command line tool that helps choose how to run a coding agent task: which workflow, which models and how much effort. It does three things:
|
|
12
12
|
|
|
13
|
-
|
|
13
|
+
- **Predicts.** For a task, it estimates each workflow's chance of meeting the task's tests or stated target, and what it costs.
|
|
14
|
+
- **Records.** When a task is done, it stores what ran, what it cost and whether the result was accepted.
|
|
15
|
+
- **Refits.** From every recorded run it updates its estimates, so the next prediction is better.
|
|
14
16
|
|
|
15
|
-
|
|
17
|
+
Three words come up everywhere:
|
|
16
18
|
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
| names OCP files, a folder of runs, an experiment's output | `loopmath-import-runs` |
|
|
21
|
-
| update, refresh or rerun the fit; what did loopmath learn | `loopmath-update-fit` |
|
|
22
|
-
| a task to do, which workflow, model or effort to use, or `option N: ...` pasted from a planning page | `loopmath-plan-task` |
|
|
23
|
-
| a task is done, or record, log or save a run | `loopmath-record-run` |
|
|
24
|
-
| nothing specific, and `exists` is false or `counts.runs` is 0 | `loopmath-onboard` |
|
|
25
|
-
| nothing specific, and `open_runs` is not empty | `loopmath-record-run` for those runs |
|
|
26
|
-
| nothing specific, and `fit.latest` is set but `fit.usable` is false (say `fit.problem` in one line) | `loopmath-update-fit` |
|
|
27
|
-
| nothing specific otherwise | tell the user in 3 lines what loopmath knows (`counts.runs` runs, fit `fit.latest`), then offer: plan the next task, bring existing runs, or see the results page (`loopmath posterior --html`) |
|
|
19
|
+
- A **workflow** is how a task is done: a shape such as `solo`, `plan_implement` or `implement_review`, plus the agent, model and effort for each piece.
|
|
20
|
+
- A **run** is one task done with one workflow: the agent sessions that did the work, their cost and the outcome.
|
|
21
|
+
- A **fit** is loopmath's current estimate of each workflow's chance and cost, with ranges. It is built from the user's recorded runs plus a starting estimate that ships inside loopmath.
|
|
28
22
|
|
|
29
|
-
|
|
23
|
+
loopmath never starts agents itself. It recommends; you start the agents, and only for the workflow the user chose.
|
|
30
24
|
|
|
31
|
-
##
|
|
25
|
+
## How to learn each job
|
|
32
26
|
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
27
|
+
The step by step instructions for each job come from the CLI: `loopmath guide <topic>`. A guide call only prints instructions; it never runs the job or changes anything. The guides ship inside the installed loopmath, so they always match its commands and JSON output, even after an upgrade. Read a job's guide in full before running the commands it names, then follow it. `loopmath guide` alone lists every topic.
|
|
28
|
+
|
|
29
|
+
Do not run loopmath commands with `--help`: the help text is written for people at a terminal and lists options the guides leave out on purpose. If a guide seems to miss something, run `loopmath doctor --json` and tell the user.
|
|
30
|
+
|
|
31
|
+
## What to do first
|
|
32
|
+
|
|
33
|
+
1. Run `loopmath status --json`. If `loopmath` is not found, tell the user to install it with `uv tool install --python 3.12 loopmath`, and stop.
|
|
34
|
+
2. Pick the guide from what the user asked for:
|
|
35
|
+
|
|
36
|
+
| When | Run and follow |
|
|
37
|
+
|---|---|
|
|
38
|
+
| set up, start or try loopmath | `loopmath guide onboard` |
|
|
39
|
+
| OCP files or a folder of finished runs to bring in | `loopmath guide import` |
|
|
40
|
+
| a task to do, or which workflow, model or effort to use | `loopmath guide plan` |
|
|
41
|
+
| a task is done: record its run, or judge two runs blind | `loopmath guide record` |
|
|
42
|
+
| update the fit, or what loopmath learned | `loopmath guide fit` |
|
|
43
|
+
| a command, flag, JSON field or exit code you need | `loopmath guide reference` |
|
|
44
|
+
|
|
45
|
+
For example, if you need to onboard the user, run `loopmath guide onboard` and follow its output.
|
|
46
|
+
|
|
47
|
+
3. If the user named no job, decide from the status, in this order:
|
|
48
|
+
- no store (`exists` false) or no runs (`counts.runs` 0): onboard;
|
|
49
|
+
- `open_runs` not empty: record, but only runs whose work is done;
|
|
50
|
+
- `fit.usable` false: fit, and say `fit.problem` in one line;
|
|
51
|
+
- otherwise say in three lines what loopmath knows (how many runs, which fit) and offer to plan the next task, bring in existing runs, or open the results page (`loopmath posterior --html`).
|
|
52
|
+
|
|
53
|
+
## Rules that always hold
|
|
54
|
+
|
|
55
|
+
- Never start agents or a run without the user's choice. A recommendation is advice, not a choice.
|
|
56
|
+
- Never edit the store (`~/.loopmath`, or `$LOOPMATH_HOME`) by hand. Only loopmath commands write there.
|
|
57
|
+
- Never record another person's sessions.
|
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
Metadata-Version: 2.4
|
|
2
2
|
Name: loopmath
|
|
3
|
-
Version: 0.3.
|
|
3
|
+
Version: 0.3.4
|
|
4
4
|
Summary: Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs
|
|
5
|
-
Author:
|
|
5
|
+
Author: loopmath
|
|
6
6
|
License-Expression: MIT
|
|
7
7
|
Project-URL: Homepage, https://github.com/loopmath/loopmath
|
|
8
8
|
Project-URL: Issues, https://github.com/loopmath/loopmath/issues
|
|
@@ -73,20 +73,21 @@ loopmath skill install # teach your coding agents how to use loopmat
|
|
|
73
73
|
|
|
74
74
|
Then ask your agent to onboard, for example "onboard loopmath". The agent runs a dry run, asks you one question (which model labels your sessions, with the cost of each option), onboards, fits, and opens the results page.
|
|
75
75
|
|
|
76
|
-
`skill install` writes
|
|
76
|
+
`skill install` writes one skill, `loopmath`. It tells the agent to check the store with `loopmath status --json`, pick the job, and read that job's guide from the CLI, so the instructions always match the loopmath you have installed. Mention loopmath in what you ask, and the skill picks the guide:
|
|
77
77
|
|
|
78
|
-
|
|
|
78
|
+
| Guide | Ask your agent |
|
|
79
79
|
|---|---|
|
|
80
|
-
| `loopmath` |
|
|
81
|
-
| `loopmath
|
|
82
|
-
| `loopmath
|
|
83
|
-
| `loopmath
|
|
84
|
-
| `loopmath
|
|
85
|
-
| `loopmath-record-run` | a task planned with loopmath is done; "record", "log" or "save" a run; both runs of a pair need a blind judge |
|
|
80
|
+
| `loopmath guide onboard` | "onboard", "set up", "start" or "try" loopmath; or loopmath has no runs yet |
|
|
81
|
+
| `loopmath guide import` | OCP files (`*.ocp.json`), a folder of finished runs, or the output of an orchestrator or experiment harness that writes OCP |
|
|
82
|
+
| `loopmath guide plan` | "plan a task with loopmath"; which workflow, model or effort to use |
|
|
83
|
+
| `loopmath guide record` | a task planned with loopmath is done; "record", "log" or "save" a run; both runs of a pair need a blind judge |
|
|
84
|
+
| `loopmath guide fit` | "update", "refresh" or "rerun" the fit; what loopmath learned; runs imported or recorded without a refit |
|
|
86
85
|
|
|
87
|
-
|
|
86
|
+
`loopmath guide` alone lists them, and `loopmath guide reference` prints the command reference they share, with every command, flag and JSON field they use. A guide is read only: it needs no store and writes nothing.
|
|
88
87
|
|
|
89
|
-
|
|
88
|
+
By default the skill goes to every agent whose home exists: Claude Code (`~/.claude/skills/loopmath/`, or under `$CLAUDE_CONFIG_DIR`) and Codex (`~/.codex/skills/loopmath/`, or under `$CODEX_HOME`). `--target claude-code`, `codex` or `both` picks them yourself. If your Codex has no skills folder, the skill goes to `~/.codex/loopmath/loopmath/` instead, with a short marked block in `~/.codex/AGENTS.md` that points to it. Add `--scope project` to install into the current repository (or `--dir PATH` for another one).
|
|
89
|
+
|
|
90
|
+
It is safe to run again. It records the files it wrote, with their hashes, in `.loopmath-skills.json` beside the skill folder, and it replaces or removes only those. A skill file you changed is kept, with a note. Any other file where the skill goes stops the install before it writes anything, and names the path to move aside. The single skill that 0.1 installed is replaced when it is as 0.1 wrote it. Upgrading from 0.2 or 0.3 removes the five job skills those versions installed and the `reference.md` copy in each skill folder, where loopmath wrote them and they are unchanged; a file you changed is kept, with a note. `--dry-run` lists every file install would write or remove. `loopmath skill show` prints the skill, and `loopmath skill uninstall` removes the files it wrote. `loopmath doctor` shows what loopmath can see: logs, agents, store, fit, prices and the skill, and names any job skill an older loopmath left behind. To read the logs it builds the log parse cache in the store and keeps it, so the next read is fast, and it says how big the cache is; it changes nothing else in the store.
|
|
90
91
|
|
|
91
92
|
To onboard by hand instead:
|
|
92
93
|
|
|
@@ -112,7 +113,7 @@ The prior ships inside the package: our runs, in the shared form (no titles, pat
|
|
|
112
113
|
|
|
113
114
|
## The loop
|
|
114
115
|
|
|
115
|
-
The plan and record
|
|
116
|
+
The plan and record guides take an agent through the loop in three commands:
|
|
116
117
|
|
|
117
118
|
```sh
|
|
118
119
|
loopmath recommend --type bug_fix --repo acme/api --title "Fix the parser crash" --json --brief --html
|
|
@@ -180,7 +181,7 @@ The workflow builder is the one page that is served: `loopmath builder --type bu
|
|
|
180
181
|
| Harness testing | `check-change`, `gate` (experimental), `screen` (experimental) |
|
|
181
182
|
| Task subsets | `tasks pick` (experimental) |
|
|
182
183
|
| Evolution loops | `adapt openevolve` (experimental), `adapt shinkaevolve` (experimental), `recommend --role` (experimental) |
|
|
183
|
-
| Skill | `skill` (install, uninstall, show) |
|
|
184
|
+
| Skill | `skill` (install, uninstall, show), `guide` |
|
|
184
185
|
| OCP | `ocp` (validate, migrate) |
|
|
185
186
|
| Log analysis | `analyze`, `graph`, `adapt`, `prices`, `validate-prices` |
|
|
186
187
|
|
|
@@ -1,10 +1,10 @@
|
|
|
1
|
-
loopmath/__init__.py,sha256=
|
|
1
|
+
loopmath/__init__.py,sha256=FwSfUFdPCwuJZg0s1wSveMcOr9gr_X7IUxADSVkttRQ,244
|
|
2
2
|
loopmath/__main__.py,sha256=X6nV3FjHmxDbIjccOYrBts_0KyJwOmDEPI5URzMO_-8,126
|
|
3
3
|
loopmath/adapter_host.py,sha256=KBLHsP-LzrRDzOaDQMJRDq-NfCJeT5nY_CQAPLqyKQ4,10284
|
|
4
|
-
loopmath/cli.py,sha256=
|
|
4
|
+
loopmath/cli.py,sha256=16RLm--_f0u9Eh9VX5-xG4l4hzgSKuwn0zDdbBTMe2I,30372
|
|
5
5
|
loopmath/cli_errors.py,sha256=pf7kuCoA--zV0L4wwj8v3JA3KrJFaDIcdLUUuSF2sRo,4839
|
|
6
6
|
loopmath/cli_graph.py,sha256=30VWDHnTEwAB_IX6CL_FluvnfAjydwrjDm0GRlBcLlQ,13492
|
|
7
|
-
loopmath/cli_registry.py,sha256=
|
|
7
|
+
loopmath/cli_registry.py,sha256=8mrRrjVNTt2BEbGyVgMW5toTi98R-tBYe0byRZf8UlU,67309
|
|
8
8
|
loopmath/cli_support.py,sha256=gD_33ELLH4oUuYtWbxoCSYr2LUpJuh3ay80sn1KpTUA,23199
|
|
9
9
|
loopmath/explain.py,sha256=fQN2ANW4fniyWdm0k14Cvioicm_Nncx7-lanVPteTUw,3166
|
|
10
10
|
loopmath/fit.py,sha256=8eelfN7KqrHVQFLvWkq0iCgHLD7Jun8shuslUFuXfmU,14680
|
|
@@ -214,7 +214,7 @@ loopmath/ocp/schema/ocp-v0.2.schema.json,sha256=T4P5gg6H2dW-28MRbg9fSNct_ejXezI6
|
|
|
214
214
|
loopmath/ocp/schema/ocp-v0.3.schema.json,sha256=uu1r4JGKc3JqBxz8m07dPrJiT64FMRZkibx048-AUug,74227
|
|
215
215
|
loopmath/ocp/schema/ocp-v0.schema.json,sha256=tOGqmvAjh0Ap09zV3QLQp3PovQB8inpVNgxSnrPS354,15279
|
|
216
216
|
loopmath/onboard/__init__.py,sha256=j0dutH36289ZKhbrX7P9fYGY-xbV6k9vSYmC5YIH120,126
|
|
217
|
-
loopmath/onboard/commands.py,sha256=
|
|
217
|
+
loopmath/onboard/commands.py,sha256=38KIZqR8VvtO5bhYc65B4SLDM6tHFsEUbu_y9nf24cc,22544
|
|
218
218
|
loopmath/onboard/history.py,sha256=qQqidw7pg-XOSQir8bcImTfP3fdFcGt8VsnrpuRMX4A,26469
|
|
219
219
|
loopmath/onboard/label.py,sha256=nKlveJNggqxKcK3I60QQF8L0y0iEcm2d-LIP0Ca3n50,19571
|
|
220
220
|
loopmath/onboard/usual.py,sha256=rEyg6WOCzEN8Y-UsHLh2br218qdca3IzRp1FVaA_qgw,3444
|
|
@@ -269,16 +269,17 @@ loopmath/share/commands.py,sha256=tFVrahWyH3nYVKF3ilVQmqXfN1YRoMsn9CCtxCv8tgM,66
|
|
|
269
269
|
loopmath/share/export.py,sha256=5UTjI9e4NCmwzceV00iKXOXS1NzbYBy7WrcVyOq5AZA,27397
|
|
270
270
|
loopmath/share/import_.py,sha256=Q-Xkr6bQaPXjgRNZi1ldnStTcQfQQDvdDNrnARhdat8,18290
|
|
271
271
|
loopmath/skill/__init__.py,sha256=-DtMdtjqlKOBIRA-3sdr1oiJHqkL5xLBNuvkteYCRFk,95
|
|
272
|
-
loopmath/skill/commands.py,sha256=
|
|
273
|
-
loopmath/skill/doctor.py,sha256=
|
|
274
|
-
loopmath/skill/
|
|
275
|
-
loopmath/skill/
|
|
276
|
-
loopmath/skill/
|
|
277
|
-
loopmath/skill/
|
|
278
|
-
loopmath/skill/
|
|
279
|
-
loopmath/skill/
|
|
280
|
-
loopmath/skill/
|
|
281
|
-
loopmath/skill/
|
|
272
|
+
loopmath/skill/commands.py,sha256=ylzGDiLHAaiewFLJbXa_FvmlHEfGdJQNZUESokDrzLg,4636
|
|
273
|
+
loopmath/skill/doctor.py,sha256=DS7rYXdH0E_uq1YMS_LMZXbkl6H465zS4epDBiNTvBk,12220
|
|
274
|
+
loopmath/skill/guide.py,sha256=CcSLpTGjGLZKu1N0IiaItZUqRiZXWVUiPQOZEibNpLo,2267
|
|
275
|
+
loopmath/skill/install.py,sha256=o1iPskwmfNCAXowYyknfLCFyNNEE1OqbyWn1IwnrLuo,29895
|
|
276
|
+
loopmath/skill/guides/fit.md,sha256=OXW_AxHXGUgR5sJ-JLdlhzAC5fEUc1pLtSaPWpw-kn8,2301
|
|
277
|
+
loopmath/skill/guides/import.md,sha256=iLjA3sABPeZtMwki3lCWPZgaaSFXgnFpp_LWqZRVIc0,2678
|
|
278
|
+
loopmath/skill/guides/onboard.md,sha256=CuN4a13hktbJssDnXXk-CQjdUAJ-h6yh87eJ8CZ-m7Q,4409
|
|
279
|
+
loopmath/skill/guides/plan.md,sha256=CG9V3opdsO1ejBJpwo56lz_01DmRt2rg0TJqs6sF-eQ,10086
|
|
280
|
+
loopmath/skill/guides/record.md,sha256=DOf0BJ-qo3AOOEtDFGuf1RYwHrq-sEezay3apUEgbKQ,6231
|
|
281
|
+
loopmath/skill/guides/reference.md,sha256=Fp7EMaPNjdmFkxW4ImxhkWRlOvxZ5gb4Par0pxXXjEU,16604
|
|
282
|
+
loopmath/skill/skills/loopmath/SKILL.md,sha256=fr2rj-2ICFAI6Vw7TtwtnWMcvcYs8QCwc-nrrW261_I,3550
|
|
282
283
|
loopmath/store/__init__.py,sha256=vCGuqOSRKmKoT4eLbjEl8kxJRwdHWqxouGTp6gqPLFE,708
|
|
283
284
|
loopmath/store/budget.py,sha256=5ra1EuTJOQ5K7xCaN2_cdqQWbPvRkyLjcBuD5K32PvY,8526
|
|
284
285
|
loopmath/store/commands.py,sha256=28Lnw-YiXZZFy5oYMPfINMXrHAoT_Z2IeCtvFgQlfVs,81726
|
|
@@ -341,12 +342,12 @@ loopmath/workflows/catalog/plan_implement.toml,sha256=qxAs6G3JGOUuW6TnhiaUXzaFfy
|
|
|
341
342
|
loopmath/workflows/catalog/plan_implement_review.toml,sha256=rRtiactglcJAynFWbrjnI-Ftbl3qe971ov9HJ3Vr7uU,862
|
|
342
343
|
loopmath/workflows/catalog/solo.toml,sha256=aJWBEEfS4DNCLqznDI3yp-7s1ZXx_rdqsEIPX7n0-nM,373
|
|
343
344
|
loopmath/workflows/catalog/swarm.toml,sha256=1hbQR41nl7VS_XN1z2fmwLCNw6kn2syowpwwauFUL3o,850
|
|
344
|
-
loopmath-0.3.
|
|
345
|
-
loopmath-0.3.
|
|
346
|
-
loopmath-0.3.
|
|
347
|
-
loopmath-0.3.
|
|
348
|
-
loopmath-0.3.
|
|
349
|
-
loopmath-0.3.
|
|
350
|
-
loopmath-0.3.
|
|
351
|
-
loopmath-0.3.
|
|
352
|
-
loopmath-0.3.
|
|
345
|
+
loopmath-0.3.4.data/data/spec/ocp-v0.2.schema.json,sha256=T4P5gg6H2dW-28MRbg9fSNct_ejXezI69-SaKR9WogU,31855
|
|
346
|
+
loopmath-0.3.4.data/data/spec/ocp-v0.schema.json,sha256=tOGqmvAjh0Ap09zV3QLQp3PovQB8inpVNgxSnrPS354,15279
|
|
347
|
+
loopmath-0.3.4.data/data/spec/ocp_conformance.py,sha256=VzRGKvC6f-64U72xrDOSJEeYa92Bpj3tEf5x0uJXqhk,893
|
|
348
|
+
loopmath-0.3.4.dist-info/licenses/LICENSE,sha256=Df5w_-_yYMWXFWcPR1Cj0pDXWBCE5_xdFN9WCNGHuGQ,1065
|
|
349
|
+
loopmath-0.3.4.dist-info/METADATA,sha256=rDpRaSxt3ZMOJ5UumjfA-XAbwg_3kcmbnfScKIbSbSA,39523
|
|
350
|
+
loopmath-0.3.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
|
|
351
|
+
loopmath-0.3.4.dist-info/entry_points.txt,sha256=WQwYqfGAwvoQ_vu6_lwQpq3V8xbK3i9SyNKPDdQ1VmQ,72
|
|
352
|
+
loopmath-0.3.4.dist-info/top_level.txt,sha256=SH9Y0Z7thA0zx1PAgHAwc1vOJaS6o3yS5HazS-LzXOg,9
|
|
353
|
+
loopmath-0.3.4.dist-info/RECORD,,
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|