abvx-set 0.2.3__py3-none-any.whl

scripts/resolve_inputs.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def _read_preset(name: str) -> dict[str, str]:
+    if not name:
+        return {}
+    preset_path = Path(__file__).resolve().parents[1] / 'presets' / f'{name}.env'
+    if not preset_path.exists():
+        available = ', '.join(sorted(p.stem for p in preset_path.parent.glob('*.env')))
+        raise SystemExit(f"Unknown workflow_preset '{name}'. Available presets: {available}")
+    values: dict[str, str] = {}
+    for line in preset_path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+        key, _, value = line.partition('=')
+        values[key.strip()] = value.strip()
+    return values
+
+
+def _resolve_flag(explicit: str, preset: dict[str, str], key: str, fallback: str) -> str:
+    if explicit in {'true', 'false'}:
+        return explicit
+    if key in preset:
+        return preset[key]
+    return fallback
+
+
+def main() -> int:
+    preset_name = os.environ.get('INPUT_WORKFLOW_PRESET', '').strip()
+    preset = _read_preset(preset_name)
+
+    resolved = {
+        'SET_RESOLVED_AGENTSGEN': _resolve_flag(os.environ.get('INPUT_AGENTSGEN', ''), preset, 'AGENTSGEN', 'true'),
+        'SET_RESOLVED_INIT': _resolve_flag(os.environ.get('INPUT_INIT', ''), preset, 'INIT', 'true'),
+        'SET_RESOLVED_PACK': _resolve_flag(os.environ.get('INPUT_PACK', ''), preset, 'PACK', 'false'),
+        'SET_RESOLVED_SITE_PACK': _resolve_flag(os.environ.get('INPUT_SITE_PACK', ''), preset, 'SITE_PACK', 'false'),
+        'SET_RESOLVED_CHECK': _resolve_flag(os.environ.get('INPUT_CHECK', ''), preset, 'CHECK', 'false'),
+        'SET_RESOLVED_REPOMAP': _resolve_flag(os.environ.get('INPUT_REPOMAP', ''), preset, 'REPOMAP', 'false'),
+        'SET_RESOLVED_SNIPPETS': _resolve_flag(os.environ.get('INPUT_SNIPPETS', ''), preset, 'SNIPPETS', 'false'),
+        'SET_RESOLVED_ANALYZE': _resolve_flag(os.environ.get('INPUT_ANALYZE', ''), preset, 'ANALYZE', 'false'),
+        'SET_RESOLVED_META': _resolve_flag(os.environ.get('INPUT_META', ''), preset, 'META', 'false'),
+        'SET_RESOLVED_PROOF_LOOP': _resolve_flag(os.environ.get('INPUT_PROOF_LOOP', ''), preset, 'PROOF_LOOP', 'false'),
+        'SET_RESOLVED_ID_ENABLED': _resolve_flag(os.environ.get('INPUT_ID_ENABLED', ''), preset, 'ID_ENABLED', 'false'),
+        'SET_RESOLVED_ID_PRE_TASK': _resolve_flag(os.environ.get('INPUT_ID_PRE_TASK', ''), preset, 'ID_PRE_TASK', 'false'),
+        'SET_RESOLVED_ID_WEEKLY_REVIEW': _resolve_flag(os.environ.get('INPUT_ID_WEEKLY_REVIEW', ''), preset, 'ID_WEEKLY_REVIEW', 'false'),
+    }
+
+    site_url = os.environ.get('INPUT_SITE_URL', '').strip()
+    analyze_url = os.environ.get('INPUT_ANALYZE_URL', '').strip()
+    meta_url = os.environ.get('INPUT_META_URL', '').strip()
+    default_site_url = site_url or preset.get('SITE_URL', '')
+    resolved['SET_RESOLVED_SITE_URL'] = default_site_url
+    resolved['SET_RESOLVED_ANALYZE_URL'] = analyze_url or default_site_url
+    resolved['SET_RESOLVED_META_URL'] = meta_url or default_site_url
+    resolved['SET_RESOLVED_PROOF_TASK_ID'] = os.environ.get('INPUT_PROOF_TASK_ID', '').strip() or preset.get('PROOF_TASK_ID', '')
+    resolved['SET_RESOLVED_ID_OWNER_ID'] = os.environ.get('INPUT_ID_OWNER_ID', '').strip() or preset.get('ID_OWNER_ID', '')
+    resolved['SET_RESOLVED_ID_TARGET'] = os.environ.get('INPUT_ID_TARGET', '').strip() or preset.get('ID_TARGET', 'set') or 'set'
+
+    output_path = os.environ['GITHUB_ENV']
+    with open(output_path, 'a', encoding='utf-8') as fh:
+        for key, value in resolved.items():
+            fh.write(f'{key}={value}\n')
+
+    summary = (
+        'SET preset resolution: '
+        f"workflow_preset={preset_name or 'none'}, "
+        f"agentsgen={resolved['SET_RESOLVED_AGENTSGEN']}, "
+        f"init={resolved['SET_RESOLVED_INIT']}, "
+        f"pack={resolved['SET_RESOLVED_PACK']}, "
+        f"site_pack={resolved['SET_RESOLVED_SITE_PACK']}, "
+        f"check={resolved['SET_RESOLVED_CHECK']}, "
+        f"repomap={resolved['SET_RESOLVED_REPOMAP']}, "
+        f"snippets={resolved['SET_RESOLVED_SNIPPETS']}, "
+        f"analyze={resolved['SET_RESOLVED_ANALYZE']}, "
+        f"meta={resolved['SET_RESOLVED_META']}, "
+        f"proof_loop={resolved['SET_RESOLVED_PROOF_LOOP']}, "
+        f"id_enabled={resolved['SET_RESOLVED_ID_ENABLED']}, "
+        f"id_pre_task={resolved['SET_RESOLVED_ID_PRE_TASK']}, "
+        f"id_weekly_review={resolved['SET_RESOLVED_ID_WEEKLY_REVIEW']}"
+    )
+    print(summary)
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

scripts/validate_registry.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+ALLOWED_PRESETS = {'minimal', 'repo-docs', 'site-ai'}
+ALLOWED_TOP_LEVEL = {'version', 'repo', 'site', 'tools', 'presets'}
+ALLOWED_SITE_KEYS = {'url'}
+ALLOWED_TOOL_BLOCKS = {'agentsgen', 'git_tweet', 'id'}
+ALLOWED_AGENTSGEN_KEYS = {
+    'init',
+    'pack',
+    'check',
+    'repomap',
+    'repomap_policy',
+    'snippets',
+    'analyze_url',
+    'meta_url',
+    'proof_loop',
+}
+ALLOWED_GIT_TWEET_KEYS = {'enabled'}
+ALLOWED_ID_KEYS = {'enabled', 'owner_id', 'target', 'pre_task', 'weekly_review'}
+
+
+def _fail(message: str) -> SystemExit:
+    return SystemExit(message)
+
+
+def _require(condition: bool, message: str) -> None:
+    if not condition:
+        raise _fail(message)
+
+
+def _validate_bool_or_none(value: object, field: str) -> None:
+    _require(value is None or isinstance(value, bool), f'{field} must be boolean or null')
+
+
+def _validate_url_or_none(value: object, field: str) -> None:
+    _require(value is None or isinstance(value, str), f'{field} must be string or null')
+
+
+def _validate_positive_int(value: object, field: str) -> None:
+    _require(isinstance(value, int) and value > 0, f'{field} must be a positive integer')
+
+
+def validate_config(path: Path) -> dict[str, object]:
+    data = json.loads(path.read_text())
+    _require(isinstance(data, dict), f'{path.name}: config must be an object')
+    unknown_top = set(data) - ALLOWED_TOP_LEVEL
+    _require(not unknown_top, f"{path.name}: unknown top-level keys: {', '.join(sorted(unknown_top))}")
+    _require(data.get('version') == 1, f'{path.name}: version must be 1')
+    repo = data.get('repo')
+    _require(isinstance(repo, str) and '/' in repo, f'{path.name}: repo must be owner/name')
+
+    site = data.get('site')
+    if site is not None:
+        _require(isinstance(site, dict), f'{path.name}: site must be an object')
+        unknown_site = set(site) - ALLOWED_SITE_KEYS
+        _require(not unknown_site, f"{path.name}: unknown site keys: {', '.join(sorted(unknown_site))}")
+        if 'url' in site:
+            _require(isinstance(site['url'], str) and site['url'].startswith('http'), f'{path.name}: site.url must be http(s) string')
+
+    tools = data.get('tools')
+    _require(isinstance(tools, dict), f'{path.name}: tools must be an object')
+    unknown_tools = set(tools) - ALLOWED_TOOL_BLOCKS
+    _require(not unknown_tools, f"{path.name}: unknown tool blocks: {', '.join(sorted(unknown_tools))}")
+
+    agentsgen = tools.get('agentsgen')
+    if agentsgen is not None:
+        _require(isinstance(agentsgen, dict), f'{path.name}: tools.agentsgen must be an object')
+        unknown_agentsgen = set(agentsgen) - ALLOWED_AGENTSGEN_KEYS
+        _require(not unknown_agentsgen, f"{path.name}: unknown agentsgen keys: {', '.join(sorted(unknown_agentsgen))}")
+        for key in ('init', 'pack', 'check', 'repomap', 'snippets'):
+            if key in agentsgen:
+                _validate_bool_or_none(agentsgen[key], f'{path.name}: agentsgen.{key}')
+        for key in ('analyze_url', 'meta_url'):
+            if key in agentsgen:
+                _validate_url_or_none(agentsgen[key], f'{path.name}: agentsgen.{key}')
+        repomap_policy = agentsgen.get('repomap_policy')
+        if repomap_policy is not None:
+            _require(isinstance(repomap_policy, dict), f'{path.name}: agentsgen.repomap_policy must be an object')
+            unknown_policy = set(repomap_policy) - {'compact_budget', 'top_ranked_files', 'focus', 'changed'}
+            _require(not unknown_policy, f"{path.name}: unknown repomap_policy keys: {', '.join(sorted(unknown_policy))}")
+            if 'compact_budget' in repomap_policy:
+                _validate_positive_int(repomap_policy['compact_budget'], f'{path.name}: agentsgen.repomap_policy.compact_budget')
+            if 'top_ranked_files' in repomap_policy:
+                _validate_positive_int(repomap_policy['top_ranked_files'], f'{path.name}: agentsgen.repomap_policy.top_ranked_files')
+            if 'focus' in repomap_policy:
+                _require(repomap_policy['focus'] is None or isinstance(repomap_policy['focus'], str), f'{path.name}: agentsgen.repomap_policy.focus must be string or null')
+            if 'changed' in repomap_policy:
+                _require(isinstance(repomap_policy['changed'], bool), f'{path.name}: agentsgen.repomap_policy.changed must be boolean')
+        proof_loop = agentsgen.get('proof_loop')
+        if proof_loop is not None:
+            _require(isinstance(proof_loop, dict), f'{path.name}: agentsgen.proof_loop must be an object')
+            unknown_proof = set(proof_loop) - {'enabled', 'task_id', 'expected_artifacts'}
+            _require(not unknown_proof, f"{path.name}: unknown proof_loop keys: {', '.join(sorted(unknown_proof))}")
+            if 'enabled' in proof_loop:
+                _require(isinstance(proof_loop['enabled'], bool), f'{path.name}: agentsgen.proof_loop.enabled must be boolean')
+            if 'task_id' in proof_loop:
+                _require(proof_loop['task_id'] is None or isinstance(proof_loop['task_id'], str), f'{path.name}: agentsgen.proof_loop.task_id must be string or null')
+            if 'expected_artifacts' in proof_loop:
+                _require(isinstance(proof_loop['expected_artifacts'], list), f'{path.name}: agentsgen.proof_loop.expected_artifacts must be a list')
+                for item in proof_loop['expected_artifacts']:
+                    _require(isinstance(item, str) and item.strip(), f'{path.name}: agentsgen.proof_loop.expected_artifacts items must be non-empty strings')
+
+    git_tweet = tools.get('git_tweet')
+    if git_tweet is not None:
+        _require(isinstance(git_tweet, dict), f'{path.name}: tools.git_tweet must be an object')
+        unknown_git_tweet = set(git_tweet) - ALLOWED_GIT_TWEET_KEYS
+        _require(not unknown_git_tweet, f"{path.name}: unknown git_tweet keys: {', '.join(sorted(unknown_git_tweet))}")
+        if 'enabled' in git_tweet:
+            _validate_bool_or_none(git_tweet['enabled'], f'{path.name}: git_tweet.enabled')
+
+    id_tool = tools.get('id')
+    if id_tool is not None:
+        _require(isinstance(id_tool, dict), f'{path.name}: tools.id must be an object')
+        unknown_id = set(id_tool) - ALLOWED_ID_KEYS
+        _require(not unknown_id, f"{path.name}: unknown id keys: {', '.join(sorted(unknown_id))}")
+        if 'enabled' in id_tool:
+            _validate_bool_or_none(id_tool['enabled'], f'{path.name}: id.enabled')
+        for key in ('pre_task', 'weekly_review'):
+            if key in id_tool:
+                _validate_bool_or_none(id_tool[key], f'{path.name}: id.{key}')
+        for key in ('owner_id', 'target'):
+            if key in id_tool:
+                _require(id_tool[key] is None or isinstance(id_tool[key], str), f'{path.name}: id.{key} must be string or null')
+
+    presets = data.get('presets', [])
+    _require(isinstance(presets, list), f'{path.name}: presets must be a list')
+    for preset in presets:
+        _require(isinstance(preset, str), f'{path.name}: preset names must be strings')
+        _require(preset in ALLOWED_PRESETS, f'{path.name}: unsupported preset {preset!r}')
+
+    return data
+
+
+def main() -> int:
+    root = Path(__file__).resolve().parents[1]
+    registry_dir = root / 'registry' / 'repos'
+    configs = sorted(registry_dir.glob('*.json'))
+    if not configs:
+        print('No registry configs found.')
+        return 0
+
+    print('SET registry validation')
+    for config_path in configs:
+        data = validate_config(config_path)
+        repo = data['repo']
+        presets = ', '.join(data.get('presets', [])) or 'none'
+        print(f'- ok: {config_path.name} -> {repo} (presets: {presets})')
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

scripts/write_summary.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+
+def _enabled(name: str) -> bool:
+    return os.environ.get(name, '').strip() == 'true'
+
+
+def _line(label: str, value: str) -> str:
+    return f'- **{label}:** {value}\n'
+
+
+def _repomap_mode(focus: str, changed: str) -> str:
+    focus_value = focus.strip()
+    changed_enabled = changed.strip() == 'true'
+    if focus_value and changed_enabled:
+        return 'focus+changed'
+    if focus_value:
+        return 'focus'
+    if changed_enabled:
+        return 'changed'
+    return 'full'
+
+
+def _repomap_label(mode: str) -> str:
+    return {
+        'full': 'Full Repo Slice',
+        'focus': 'Focused Code Slice',
+        'changed': 'Changed Files Slice',
+        'focus+changed': 'Hybrid Slice',
+    }.get(mode, 'Full Repo Slice')
+
+
+def _load_json(path: Path) -> dict[str, object] | None:
+    if not path.exists():
+        return None
+    try:
+        payload = json.loads(path.read_text(encoding='utf-8'))
+    except Exception:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def main() -> int:
+    summary_path = os.environ.get('GITHUB_STEP_SUMMARY', '').strip()
+    if not summary_path:
+        print('SET summary skipped: GITHUB_STEP_SUMMARY is not available.')
+        return 0
+
+    workflow_preset = os.environ.get('INPUT_WORKFLOW_PRESET', '').strip() or 'none'
+    path_value = os.environ.get('INPUT_PATH', '.').strip() or '.'
+    autodetect = os.environ.get('INPUT_AUTODETECT', 'true').strip() or 'true'
+    init_preset = os.environ.get('INPUT_PRESET', '').strip() or 'none'
+
+    operations: list[str] = []
+    if _enabled('SET_RESOLVED_INIT'):
+        operations.append('init')
+    if _enabled('SET_RESOLVED_PACK') and _enabled('SET_RESOLVED_SITE_PACK'):
+        operations.append('pack --site')
+    elif _enabled('SET_RESOLVED_PACK'):
+        operations.append('pack')
+    if _enabled('SET_RESOLVED_CHECK'):
+        operations.append('check --all --ci')
+    if _enabled('SET_RESOLVED_REPOMAP'):
+        operations.append('understand')
+    if _enabled('SET_RESOLVED_SNIPPETS'):
+        operations.append('snippets')
+    if _enabled('SET_RESOLVED_ANALYZE'):
+        operations.append('analyze')
+    if _enabled('SET_RESOLVED_META'):
+        operations.append('meta')
+    if _enabled('SET_RESOLVED_PROOF_LOOP'):
+        operations.append('proof-loop')
+    if _enabled('SET_RESOLVED_ID_ENABLED') and _enabled('SET_RESOLVED_ID_PRE_TASK'):
+        operations.append('id pre_task')
+    if _enabled('SET_RESOLVED_ID_ENABLED') and _enabled('SET_RESOLVED_ID_WEEKLY_REVIEW'):
+        operations.append('id weekly_review')
+
+    body = []
+    body.append('## SET execution summary\n\n')
+    body.append(_line('workflow preset', workflow_preset))
+    body.append(_line('path', f'`{path_value}`'))
+    body.append(_line('autodetect', autodetect))
+    body.append(_line('init preset', init_preset))
+    body.append(_line('agentsgen ref', os.environ.get('INPUT_AGENTSGEN_REF', 'main').strip() or 'main'))
+    body.append(_line('operations', ', '.join(operations) if operations else 'none'))
+
+    site_url = os.environ.get('SET_RESOLVED_SITE_URL', '').strip()
+    analyze_url = os.environ.get('SET_RESOLVED_ANALYZE_URL', '').strip()
+    meta_url = os.environ.get('SET_RESOLVED_META_URL', '').strip()
+    repomap_budget = os.environ.get('INPUT_REPOMAP_COMPACT_BUDGET', '').strip() or '4000'
+    repomap_focus = os.environ.get('INPUT_REPOMAP_FOCUS', '').strip()
+    repomap_changed = os.environ.get('INPUT_REPOMAP_CHANGED', '').strip()
+    id_owner_id = os.environ.get('SET_RESOLVED_ID_OWNER_ID', '').strip() or os.environ.get('INPUT_ID_OWNER_ID', '').strip()
+    id_target = os.environ.get('SET_RESOLVED_ID_TARGET', '').strip() or os.environ.get('INPUT_ID_TARGET', '').strip() or 'set'
+    if _enabled('SET_RESOLVED_REPOMAP'):
+        repomap_mode = _repomap_mode(repomap_focus, repomap_changed)
+        body.append(_line('repomap compact budget', repomap_budget))
+        body.append(_line('repomap policy mode', repomap_mode))
+        body.append(_line('repomap policy label', _repomap_label(repomap_mode)))
+        body.append(_line('repomap slice', repomap_focus if repomap_focus else ('changed' if repomap_changed == 'true' else 'full')))
+    if _enabled('SET_RESOLVED_ID_ENABLED'):
+        body.append(_line('id integration', 'enabled'))
+        body.append(_line('id owner id', id_owner_id or 'missing'))
+        body.append(_line('id target', id_target))
+        body.append(_line('id pre_task', str(_enabled('SET_RESOLVED_ID_PRE_TASK')).lower()))
+        body.append(_line('id weekly_review', str(_enabled('SET_RESOLVED_ID_WEEKLY_REVIEW')).lower()))
+    if _enabled('SET_RESOLVED_PROOF_LOOP'):
+        body.append(_line('proof loop', 'enabled'))
+        proof_task_id = os.environ.get('SET_RESOLVED_PROOF_TASK_ID', '').strip() or 'missing'
+        body.append(_line('proof task id', proof_task_id))
+        repo_root = Path(path_value)
+        proof_dir = repo_root / 'docs' / 'ai' / 'tasks' / proof_task_id
+        evidence = _load_json(proof_dir / 'evidence.json') or _load_json(proof_dir / 'evidence.generated.json')
+        verdict = _load_json(proof_dir / 'verdict.json') or _load_json(proof_dir / 'verdict.generated.json')
+        if isinstance(evidence, dict):
+            body.append(_line('proof evidence status', str(evidence.get('evidence_status', 'unknown'))))
+            check_summary = evidence.get('check_summary')
+            artifact_summary = evidence.get('artifact_summary')
+            if isinstance(check_summary, dict):
+                body.append(
+                    _line(
+                        'proof checks',
+                        f"passed {check_summary.get('passed', 0)}, failed {check_summary.get('failed', 0)}, pending {check_summary.get('pending', 0)}",
+                    )
+                )
+            if isinstance(artifact_summary, dict):
+                body.append(
+                    _line(
+                        'proof artifacts',
+                        f"present {artifact_summary.get('present', 0)} / total {artifact_summary.get('total', 0)}",
+                    )
+                )
+        if isinstance(verdict, dict):
+            body.append(_line('proof verdict', str(verdict.get('status', 'unknown'))))
+            body.append(_line('proof decision', str(verdict.get('decision', 'unknown'))))
+            body.append(_line('proof blockers', str(len(verdict.get('blocking_details', []) or verdict.get('blocking_items', []) or []))))
+            body.append(_line('proof ready for apply', str(verdict.get('ready_for_apply', False)).lower()))
+            recommendation = str(verdict.get('recommendation', '') or '')
+            if recommendation:
+                body.append(_line('proof recommendation', recommendation))
+
+    if site_url:
+        body.append(_line('site url', site_url))
+    if _enabled('SET_RESOLVED_ANALYZE') and analyze_url:
+        body.append(_line('analyze url', analyze_url))
+    if _enabled('SET_RESOLVED_META') and meta_url:
+        body.append(_line('meta url', meta_url))
+
+    with Path(summary_path).open('a', encoding='utf-8') as fh:
+        fh.writelines(body)
+
+    print('SET execution summary written.')
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())