SuperAPI AI Directory

local-impl-logger

Coding & development

View repository

Updated 10-16 02:39

About this skill

Local Implementation Logger (filesystem tracker)

Role

You record what was implemented for a task as a structured entry in the local filesystem tracker — appended to the work-item file's ## Activity Log and mirrored to documentation/impl-logs/{id}.md. The log is the canonical knowledge base for "what exists already" — future engineers and AI agents should grep documentation/ before creating new code.

You are the offline parallel of jira-impl-logger / linear-impl-logger. The workflow (and task-executor / sprint-executor via the adapter's implLogger) routes here when tracker: local. You are invoked once per completed task, or directly to backfill a log.

Why local and not a service: when there is no JIRA/Linear MCP, the impl log still needs a durable, searchable home. Repo files are git-versioned, grep-able, and link naturally to the work-item's full context (description, activity, state). The store format is defined in skills/task-executor/references/tracker-local.md.

Inputs

  • Item id (e.g., LOC-102)
  • Summary — one-line description of what was implemented
  • Files created — list of paths
  • Files modified — list of paths
  • Statistics — linesAdded, linesRemoved (from git diff --shortstat)
  • Artifacts — structured data about what was built (see schema below)
  • Commit hash(es) — for back-reference
  • Optional: docs backend — docs: confluence | notion | local (from workflow-config) for the docs mirror

Artifact Schema

Structured data, adapted from spec-workflow-mcp. Each artifact type (apiEndpoints, components, functions, classes, integrations, dataModels, pipelineStages) is optional — include the ones relevant to this task.

The schema is defined once, shared verbatim across all four impl-loggers — see prompts/coding/templates/impl-log-artifact-schema.md.

Workflow

Step 1 — Validate Inputs

  • Confirm the item file exists (Read documentation/tracker/{id}.md)
  • Confirm at least one artifact category is provided — empty artifacts is a failure mode
  • Confirm files lists are non-empty (a task that created/modified no files is suspicious)

If inputs are thin, ask the caller for more detail before posting. A sparse log is worse than no log — it pollutes search results.

Step 2 — Render the Log

Use the same structure as prompts/coding/templates/jira-impl-log-template.md:

### Implementation Log — {id} — {ISO date}

**Summary:** {one-line summary}
**Commit:** {hash} — {commit message first line}

#### Files
- Created: {file1}, {file2}
- Modified: {file3}, {file4}
- Stats: +{linesAdded} / -{linesRemoved} across {N} files

#### Artifacts

##### API Endpoints
| Method | Path | Purpose | Location |
| ... | ... | ... | ... |

##### Components
| Name | Type | Purpose | Location | Props |

##### Functions
| Name | Purpose | Location | Signature | Exported |

##### Classes
| Name | Purpose | Location | Methods | Exported |

##### Integrations
| Description | Frontend | Backend | Data flow |

##### Data Models
...

##### Pipeline Stages
...

#### Searchable Keywords
{comma-separated list of class/function/endpoint names for grep}

Step 3 — Append to the Activity Log

Edit documentation/tracker/{id}.md to append the rendered log under the item's ## Activity Log section (create the section if absent). This is the comment() operation from the local tracker adapter — the work-item file is the system of record.

Step 4 — Mirror to documentation/impl-logs/

Write documentation/impl-logs/{id}.md with the rendered log (and a header linking back to ../tracker/{id}.md). This gives a flat, grep-friendly corpus of all impl logs across the project — the local equivalent of "search JIRA/Linear for what exists." If documentation/impl-logs/ doesn't exist, create it.

Step 5 — Label the Item

addLabel({id}, "impl-logged") via the local adapter (append to the labels: frontmatter). This lets the board view and grep filter items that have logs vs. those still missing them.

Step 6 — Docs mirror (optional, when docs ≠ local)

If docs is a remote backend (confluence | notion), also publish the log via the docs adapter's publishRecord (skills/feature-spec-author/references/docs-adapter.md) — a row in the Notion Impl Logs DB or an append to the Confluence Impl Logs page. When docs: local, Step 4 already is the docs mirror — do not duplicate.

Step 7 — Return

Return to caller:

  • Path to the updated work-item file (and the anchor of the appended log)
  • Path to the mirrored documentation/impl-logs/{id}.md
  • Confirmation that the item is labelled impl-logged

Why Structured Artifacts Matter

Future AI agents will grep documentation/impl-logs/ and documentation/tracker/ before writing new code. Incomplete logs produce duplicate endpoints, duplicate components, duplicate helpers.

Minimum quality bar:

  • If the task created an API endpoint, apiEndpoints MUST be populated
  • If the task created a UI component, components MUST be populated
  • If the task created a class, classes MUST be populated
  • A pure refactor (no new public surface) may have empty artifacts but MUST explain in summary: "Refactor only — no new public surface"

Backfilling Logs

If invoked on a closed item that never got a log:

  1. Read the item file's description and any commits referenced
  2. git log --follow and git show to identify files and stats
  3. Infer artifacts from the diff (grep for def , class , @app.route, React component exports)
  4. Offer the draft log to the user for confirmation before writing

What This Skill Does NOT Do

  • Does not evaluate code quality (that's clean-code-reviewer)
  • Does not change the work-item's state (that's task-executor / sprint-executor)
  • Does not call any MCP — it is pure filesystem
  • Does not add commits or run tests

References

  • skills/task-executor/references/tracker-local.md — the local tracker store format (read this first).
  • skills/jira-impl-logger/SKILL.md · skills/linear-impl-logger/SKILL.md — the JIRA / Linear parallels (same artifact schema).
  • skills/feature-spec-author/references/docs-adapter.md — the docs adapter (Step 6, remote docs mirror).
  • prompts/coding/templates/jira-impl-log-template.md — the log content template.
  • Origin schema: https://github.com/Pimzino/spec-workflow-mcp log-implementation tool

Feedback

If the user corrects this skill's output due to a misinterpretation or missing rule in the skill itself (not a one-off preference), invoke skill-feedback to capture structured feedback and optionally post a GitHub issue.

If skill-feedback is not installed, ask the user: "This looks like a skill defect. Would you like to install the skill-feedback skill to report it?" If the user declines, continue without feedback capture.