@sushanglewis/lincoln 1.5.0 → 1.5.1

package/framework/scripts/static-check.sh

@@ -0,0 +1,356 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+
+STATIC_CHECK_RESULT="$ROOT/.context/static-check-result.json"
+mkdir -p "$ROOT/.context"
+
+# Prefer project venv if available; otherwise rely on system python3 having pytest/pyyaml.
+if [ -d "$ROOT/.venv" ] && [ -x "$ROOT/.venv/bin/python3" ]; then
+    PYTHON="$ROOT/.venv/bin/python3"
+elif [ -d "$ROOT/venv" ] && [ -x "$ROOT/venv/bin/python3" ]; then
+    PYTHON="$ROOT/venv/bin/python3"
+else
+    PYTHON="python3"
+fi
+
+# Record a structured pass/fail result so benchmark metrics can consume it
+# instead of regex-scanning the command text.
+write_static_check_result() {
+    local passed="$1"
+    "$PYTHON" - "$passed" <<'PY'
+import sys, json
+from datetime import datetime, timezone
+passed = sys.argv[1] == "true"
+print(json.dumps({
+    "passed": passed,
+    "timestamp": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+}, ensure_ascii=False))
+PY
+}
+
+trap 'write_static_check_result false > "$STATIC_CHECK_RESULT"' ERR
+
+echo "==> Validate workflow YAML"
+"$PYTHON" -c "import yaml; yaml.safe_load(open('.claude/workflows/interview-to-knowledge.yaml'))"
+
+echo "==> Validate skill manifests"
+for skill in .claude/skills/*/SKILL.md; do
+    [ -f "$skill" ] || continue
+    "$PYTHON" - "$skill" <<'PY'
+import sys, yaml
+path = sys.argv[1]
+text = open(path, encoding="utf-8").read()
+if text.startswith("---"):
+    end = text.find("---", 3)
+    if end != -1:
+        frontmatter = text[3:end]
+        try:
+            yaml.safe_load(frontmatter)
+        except Exception as exc:
+            print(f"Invalid frontmatter in {path}: {exc}")
+            sys.exit(1)
+print(f"OK: {path}")
+PY
+    if [ $? -ne 0 ]; then
+        exit 1
+    fi
+done
+
+echo "==> Validate skill dependency manifest"
+DEP_FILE=".claude/skills/dependencies.yaml"
+if [ ! -f "$DEP_FILE" ]; then
+    DEP_FILE=".claude/skill-dependencies.yaml"
+fi
+"$PYTHON" -c "import yaml; yaml.safe_load(open('$DEP_FILE'))"
+
+if [ -x "scripts/check-skill-dependencies.sh" ]; then
+    echo "==> Check skill dependencies (non-blocking)"
+    bash scripts/check-skill-dependencies.sh || true
+fi
+
+echo "==> Validate workflow templates reference stage YAMLs"
+"$PYTHON" - "$ROOT" <<'PY'
+import sys
+from pathlib import Path
+import yaml
+
+root = Path(sys.argv[1])
+templates_dir = root / ".claude" / "workflows" / "templates"
+main_workflow = root / ".claude" / "workflows" / "interview-to-knowledge.yaml"
+errors = []
+
+for path in list(templates_dir.glob("*.yaml")) + [main_workflow]:
+    if not path.exists():
+        continue
+    try:
+        data = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        errors.append(f"{path.name}: YAML parse error: {exc}")
+        continue
+    workflow = data.get("workflow", data)
+    for step in workflow.get("steps", []):
+        stage_id = step.get("id")
+        if not stage_id:
+            errors.append(f"{path.name}: step missing id")
+            continue
+        stage_yaml = root / ".claude" / "stages" / f"{stage_id}.yaml"
+        if not stage_yaml.exists():
+            errors.append(f"{path.name}: missing stage YAML {stage_yaml}")
+
+if errors:
+    print("Workflow template issues:")
+    for e in errors:
+        print(f"  - {e}")
+    sys.exit(1)
+
+print("All workflow templates reference valid stage YAMLs.")
+PY
+
+echo "==> Validate JSON schemas are valid JSON"
+"$PYTHON" - "$ROOT" <<'PY'
+import sys, json
+from pathlib import Path
+root = Path(sys.argv[1])
+errors = []
+for schema_path in (root / ".claude" / "schemas").glob("*.json"):
+    try:
+        json.loads(schema_path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        errors.append(f"{schema_path.name}: {exc}")
+if errors:
+    print("Invalid JSON schemas:")
+    for e in errors:
+        print(f"  - {e}")
+    sys.exit(1)
+print("All JSON schemas are valid.")
+PY
+
+echo "==> Validate agent frontmatters"
+"$PYTHON" - "$ROOT" <<'PY'
+import sys, yaml
+from pathlib import Path
+
+root = Path(sys.argv[1])
+errors = []
+for agent_md in (root / ".claude" / "agents").glob("*.md"):
+    text = agent_md.read_text(encoding="utf-8")
+    if not text.startswith("---"):
+        errors.append(f"{agent_md.name}: missing frontmatter")
+        continue
+    end = text.find("---", 3)
+    if end == -1:
+        errors.append(f"{agent_md.name}: unterminated frontmatter")
+        continue
+    try:
+        fm = yaml.safe_load(text[3:end])
+    except Exception as exc:
+        errors.append(f"{agent_md.name}: invalid frontmatter: {exc}")
+        continue
+    if not isinstance(fm, dict):
+        errors.append(f"{agent_md.name}: frontmatter is not a mapping")
+        continue
+    for key in ["name", "description"]:
+        if key not in fm:
+            errors.append(f"{agent_md.name}: missing {key}")
+if errors:
+    print("Agent frontmatter issues:")
+    for e in errors:
+        print(f"  - {e}")
+    sys.exit(1)
+print("All agent frontmatters valid.")
+PY
+
+echo "==> Validate Python syntax"
+"$PYTHON" -m py_compile scripts/validate_stage.py
+
+echo "==> Validate prompt paths in skills"
+"$PYTHON" - "$ROOT" <<'PY'
+import sys
+from pathlib import Path
+
+root = Path(sys.argv[1])
+missing = []
+for skill_dir in (root / ".claude" / "skills").iterdir():
+    if not skill_dir.is_dir():
+        continue
+    skill_md = skill_dir / "SKILL.md"
+    if not skill_md.exists():
+        continue
+    text = skill_md.read_text(encoding="utf-8")
+    # Only enforce prompts/main.md when the skill explicitly declares it as entry
+    if "prompts/main.md" not in text:
+        continue
+    main_prompt = skill_dir / "prompts" / "main.md"
+    if not main_prompt.exists():
+        missing.append(str(main_prompt))
+if missing:
+    print("Missing prompts:")
+    for m in missing:
+        print(f"  - {m}")
+    sys.exit(1)
+print("All prompt paths resolved.")
+PY
+
+echo "==> Validate workflow-stage.yaml schema"
+"$PYTHON" - "$ROOT" <<'PY'
+import sys
+from pathlib import Path
+import yaml
+
+root = Path(sys.argv[1])
+state_file = root / ".claude" / "workflow-stage.yaml"
+legacy_state_file = root / ".claude" / "workflow-state.yaml"
+if not state_file.exists() and legacy_state_file.exists():
+    state_file = legacy_state_file
+
+if not state_file.exists():
+    print("workflow-stage.yaml not found; skipping")
+    sys.exit(0)
+
+state = yaml.safe_load(state_file.read_text(encoding="utf-8"))
+required_top_legacy = ["schema_version", "workflow", "current_run", "stages", "recovery"]
+required_top_new = ["schema_version", "workflow", "current_run", "nodes", "recovery"]
+if "nodes" in state:
+    missing = [k for k in required_top_new if k not in state]
+elif "stages" in state:
+    missing = [k for k in required_top_legacy if k not in state]
+else:
+    missing = [k for k in required_top_new if k not in state]
+if missing:
+    print(f"Missing top-level keys: {', '.join(missing)}")
+    sys.exit(1)
+
+print("workflow-stage.yaml schema valid.")
+PY
+
+echo "==> Validate stage YAML files"
+"$PYTHON" - "$ROOT" <<'PY'
+import sys
+from pathlib import Path
+import yaml
+
+root = Path(sys.argv[1])
+errors = []
+for stage_yaml in sorted((root / ".claude" / "stages").glob("*.yaml")):
+    if stage_yaml.name == "stage-manifest.yaml":
+        continue
+    try:
+        data = yaml.safe_load(stage_yaml.read_text(encoding="utf-8"))
+    except Exception as exc:
+        errors.append(f"{stage_yaml.name}: YAML parse error: {exc}")
+        continue
+    if not isinstance(data, dict):
+        errors.append(f"{stage_yaml.name}: root is not a mapping")
+        continue
+    for key in ["schema_version", "id", "name", "description", "templates", "prerequisite_stage", "next_stage", "human_gate", "agent", "skills", "artifacts", "context", "gates"]:
+        if key not in data:
+            errors.append(f"{stage_yaml.name}: missing key '{key}'")
+
+if errors:
+    print("Stage YAML issues:")
+    for e in errors:
+        print(f"  - {e}")
+    sys.exit(1)
+print("All stage YAML files valid.")
+PY
+
+echo "==> Validate stage YAML files against schema"
+"$PYTHON" - "$ROOT" <<'PY'
+import sys
+from pathlib import Path
+import yaml
+import json
+
+root = Path(sys.argv[1])
+schema_path = root / ".claude" / "schemas" / "stage-definition.schema.json"
+schema = json.loads(schema_path.read_text(encoding="utf-8"))
+
+# Minimal structural validation
+required = set(schema.get("required", []))
+errors = []
+for stage_yaml in sorted((root / ".claude" / "stages").glob("*.yaml")):
+    if stage_yaml.name == "stage-manifest.yaml":
+        continue
+    try:
+        data = yaml.safe_load(stage_yaml.read_text(encoding="utf-8"))
+    except Exception as exc:
+        errors.append(f"{stage_yaml.name}: YAML parse error: {exc}")
+        continue
+    missing = required - set(data.keys())
+    if missing:
+        errors.append(f"{stage_yaml.name}: missing required keys: {', '.join(sorted(missing))}")
+
+if errors:
+    print("Stage schema issues:")
+    for e in errors:
+        print(f"  - {e}")
+    sys.exit(1)
+print("All stage YAML files match required schema.")
+PY
+
+echo "==> Validate hook scripts are executable"
+for hook in "$ROOT/.claude/hooks/"*.sh; do
+    if [ -f "$hook" ] && [ ! -x "$hook" ]; then
+        echo "Hook not executable: $hook"
+        exit 1
+    fi
+done
+echo "All hooks executable."
+
+echo "==> Validate Python syntax for scripts"
+# Compile every Python script under scripts/ (skip __pycache__ and non-.py files)
+py_errors=0
+for pyfile in scripts/*.py; do
+    [ -f "$pyfile" ] || continue
+    if ! "$PYTHON" -m py_compile "$pyfile"; then
+        py_errors=$((py_errors + 1))
+    fi
+done
+if [ $py_errors -ne 0 ]; then
+    echo "Python syntax errors detected: $py_errors"
+    exit 1
+fi
+
+echo "==> Check command-map drift"
+"$PYTHON" scripts/lincoln_command_map.py --check
+
+echo "==> Check main merge hygiene"
+"$PYTHON" scripts/check-main-merge-hygiene.py || true
+
+echo "==> Validate bash syntax for scripts"
+bash -n scripts/init-lincoln-branch.sh
+bash -n scripts/init-project.sh
+bash -n scripts/list-active-lincoln-branches.sh
+bash -n scripts/check-skill-dependencies.sh
+bash -n scripts/sync-external-agents.sh
+bash -n scripts/check-harness-drift.sh
+for hook in "$ROOT/.claude/hooks/"*.sh; do
+    bash -n "$hook"
+done
+
+echo "==> Check harness drift"
+bash scripts/check-harness-drift.sh
+
+echo "==> Check version lockstep"
+"$PYTHON" scripts/bump_version.py --check
+
+echo "==> Check plugin package manifest"
+find .claude scripts tools -type d -name __pycache__ -prune -exec rm -rf {} + 2>/dev/null || true
+"$PYTHON" scripts/package-lincoln-plugin.py check
+
+echo "==> Run pytest"
+"$PYTHON" -m pytest tests/ -v
+pytest_exit=$?
+
+if [ $pytest_exit -eq 0 ]; then
+    write_static_check_result true > "$STATIC_CHECK_RESULT"
+    echo "==> All static checks passed"
+else
+    write_static_check_result false > "$STATIC_CHECK_RESULT"
+    echo "==> Static checks failed"
+fi
+
+exit $pytest_exit

package/framework/scripts/sync-external-agents.sh

@@ -0,0 +1,210 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Sync external agent definitions declared by .claude/agents/external/*.manifest.yaml.
+# Usage:
+#   scripts/sync-external-agents.sh
+#   scripts/sync-external-agents.sh --dry-run
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+cd "$ROOT"
+
+DRY_RUN=false
+if [[ "${1:-}" == "--dry-run" ]]; then
+    DRY_RUN=true
+fi
+
+AGENTS_DIR="$ROOT/.claude/agents/external"
+mkdir -p "$AGENTS_DIR"
+
+"$ROOT/.venv/bin/python3" - "$AGENTS_DIR" "$DRY_RUN" <<'PY'
+import sys
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import yaml
+
+agents_dir = Path(sys.argv[1])
+dry_run = sys.argv[2].lower() == "true"
+
+KNOWN_FIELDS = {"name", "description", "extends", "model", "tools", "disallowed_tools"}
+PERMISSIVE_LICENSES = {"mit", "apache-2.0", "bsd-3-clause", "bsd-2-clause", "isc"}
+
+
+def slugify(value: str) -> str:
+    value = re.sub(r"[^\w\s-]", "", value).strip().lower()
+    return re.sub(r"[-\s]+", "-", value)
+
+
+def normalize_frontmatter(text: str, prefix: str, source: str, ref: str, license_key: str, original_name: str) -> str:
+    if not text.startswith("---"):
+        return text
+    parts = text.split("---", 2)
+    if len(parts) < 3:
+        return text
+    try:
+        front = yaml.safe_load(parts[1]) or {}
+    except yaml.YAMLError:
+        return text
+
+    if not isinstance(front, dict):
+        front = {}
+
+    normalized = {k: v for k, v in front.items() if k in KNOWN_FIELDS}
+
+    # Prefix the agent name to avoid collisions.
+    normalized["name"] = f"{prefix}-{slugify(original_name)}"
+    normalized["original_name"] = original_name
+    normalized["source"] = source
+    normalized["ref"] = ref
+    normalized["license"] = license_key
+
+    # Map camelCase / legacy fields.
+    if "disallowedTools" in front and "disallowed_tools" not in normalized:
+        normalized["disallowed_tools"] = front["disallowedTools"]
+
+    # Resolve inherited models.
+    model = normalized.get("model")
+    if isinstance(model, str):
+        model = model.lower().strip()
+        if model in {"inherit", "default", "auto"}:
+            normalized["model"] = "sonnet"
+    if "model" not in normalized:
+        normalized["model"] = "sonnet"
+
+    # Remove extends from imported standalone agents; Lincoln wrappers handle composition.
+    normalized.pop("extends", None)
+
+    normalized_yaml = yaml.safe_dump(normalized, sort_keys=False, allow_unicode=True)
+    attribution = (
+        f"<!-- Imported from {source} @ {ref}, licensed under {license_key}. "
+        f"Original name: {original_name}. -->"
+    )
+    body = parts[2].lstrip("\n")
+    return f"---\n{normalized_yaml}---\n\n{attribution}\n\n{body}"
+
+
+def parse_manifest(manifest_path: Path) -> dict | None:
+    docs = list(yaml.safe_load_all(manifest_path.read_text(encoding="utf-8")))
+    data = docs[0] if docs else None
+    if not isinstance(data, dict):
+        print(f"Skipping {manifest_path.name}: invalid manifest")
+        return None
+    return data
+
+
+def agent_source_path(agents_subdir: str, imported: str) -> str:
+    if imported.endswith(".md"):
+        return f"{agents_subdir}/{imported}"
+    return f"{agents_subdir}/{imported}.md"
+
+
+def agent_basename(imported: str) -> str:
+    name = imported[:-3] if imported.endswith(".md") else imported
+    return Path(name).name
+
+
+notices = []
+notices.append("# 外部 Agent 来源声明\n")
+notices.append("本文件由 `scripts/sync-external-agents.sh` 自动生成，请勿手动修改。\n")
+notices.append("| Lincoln 文件名 | 原始名称 | 来源仓库 | 引用 | 许可证 |")
+notices.append("|---|---|---|---|---|")
+
+for manifest_path in sorted(agents_dir.glob("*.manifest.yaml")):
+    data = parse_manifest(manifest_path)
+    if data is None:
+        continue
+
+    framework = manifest_path.stem.replace(".manifest", "")
+    source = data.get("source", "")
+    ref = data.get("ref", "main") or "main"
+    license_key = (data.get("license", "") or "").lower()
+    prefix = data.get("prefix", framework)
+    agents_subdir = data.get("paths", {}).get("agents", ".claude/agents")
+    imported_agents = data.get("imported_agents", [])
+
+    if not source:
+        print(f"Skipping {manifest_path.name}: no source declared")
+        continue
+    if license_key not in PERMISSIVE_LICENSES:
+        print(f"Skipping {manifest_path.name}: license '{license_key}' is not permissive")
+        continue
+    if not imported_agents:
+        print(f"Skipping {manifest_path.name}: no imported_agents")
+        continue
+
+    target_dir = agents_dir / framework / "agents"
+    print(f"Syncing {framework} from {source} @ {ref}")
+
+    if dry_run:
+        print(f"  [dry-run] Would clone/sparse-checkout into {agents_dir / framework}")
+        for imported in imported_agents:
+            print(f"  [dry-run] Would import {imported} as {prefix}-{slugify(agent_basename(imported))}")
+        continue
+
+    if target_dir.exists():
+        shutil.rmtree(target_dir.parent)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    repo_dir = agents_dir / framework / ".repo"
+    if repo_dir.exists():
+        shutil.rmtree(repo_dir)
+    repo_dir.mkdir(parents=True, exist_ok=True)
+
+    sparse_paths = [agent_source_path(agents_subdir, imp) for imp in imported_agents]
+
+    try:
+        subprocess.run(
+            [
+                "git", "clone", "--depth", "1", "--branch", ref,
+                "--filter=blob:none", "--sparse", source, str(repo_dir),
+            ],
+            check=True,
+            capture_output=True,
+        )
+        subprocess.run(
+            ["git", "sparse-checkout", "set", "--no-cone", *sparse_paths],
+            cwd=repo_dir,
+            check=True,
+            capture_output=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        print(f"  Failed to sync {framework}: {exc}")
+        if exc.stderr:
+            print(exc.stderr.decode("utf-8", errors="replace"))
+        continue
+
+    # Copy and normalize each imported agent.
+    for imported in imported_agents:
+        src_rel = agent_source_path(agents_subdir, imported)
+        src_file = repo_dir / src_rel
+        original_name = agent_basename(imported)
+        normalized_name = f"{prefix}-{slugify(original_name)}"
+        dest_file = target_dir / f"{normalized_name}.md"
+
+        if not src_file.exists():
+            print(f"  Warning: expected agent file not found: {src_rel}")
+            continue
+
+        raw_text = src_file.read_text(encoding="utf-8")
+        normalized_text = normalize_frontmatter(
+            raw_text, prefix, source, ref, license_key, original_name
+        )
+        dest_file.write_text(normalized_text, encoding="utf-8")
+        notices.append(
+            f"| {normalized_name}.md | {original_name} | {source} | {ref} | {license_key.upper()} |"
+        )
+        print(f"  Imported {normalized_name}")
+
+    # Clean up the temporary clone.
+    shutil.rmtree(repo_dir)
+
+# Write NOTICES.md
+notices_path = agents_dir / "NOTICES.md"
+notices_path.write_text("\n".join(notices) + "\n", encoding="utf-8")
+print(f"Wrote {notices_path}")
+
+print("External agent sync complete.")
+PY