@xn-intenton-z2a/agentic-lib 7.3.0 → 7.4.1

package/.github/workflows/agentic-lib-init.yml

@@ -67,18 +67,22 @@ on:
         default: "hamming-distance"
         options:
           - hamming-distance
+          - agi
+          - ascii-face
+          - c64-emulator
+          - cron-engine
+          - dense-encoding
           - fizz-buzz
-          - roman-numerals
+          - hello-world
+          - json-schema-diff
           - lunar-lander
-          - string-utils
-          - dense-encoding
-          - plot-code-lib
-          - cron-engine
+          - markdown-compiler
           - owl-ontology
-          - time-series-lab
-          - c64-emulator
+          - plot-code-lib
           - ray-tracer
-          - markdown-compiler
+          - roman-numerals
+          - string-utils
+          - time-series-lab
           - empty
       mission-text:
         description: "Freeform mission text for MISSION.md (overrides mission-seed if provided)"
@@ -250,10 +254,10 @@ jobs:
 
             const SCHEDULE_MAP = {
               off: null,
-              weekly: '15 6 * * 1',
-              daily: '15 6 * * *',
-              hourly: '15 * * * *',
-              continuous: '5,15,25,35,45,55 * * * *',
+              weekly: '25 6 * * 1',
+              daily: '25 6 * * *',
+              hourly: '25 * * * *',
+              continuous: '5,25,45 * * * *',
             };
 
             if (fs.existsSync(workflowPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xn-intenton-z2a/agentic-lib",
-  "version": "7.3.0",
+  "version": "7.4.1",
   "description": "Agentic-lib Agentic Coding Systems SDK powering automated GitHub workflows.",
   "type": "module",
   "scripts": {

package/src/actions/commit-if-changed/action.yml

@@ -35,8 +35,12 @@ runs:
         fi
         if ! git diff --cached --quiet; then
           git commit -m "${{ inputs.commit-message }}"
+          # Stash any unstaged changes (e.g. log/screenshot files we just unstaged)
+          # so that git pull --rebase can work cleanly
+          git stash 2>/dev/null || true
           REF="${{ inputs.push-ref }}"
           MAX_RETRIES=3
+          PUSH_SUCCESS=""
           REMOTE_REF_EXISTS=""
           if [ -n "$REF" ]; then
             git ls-remote --exit-code origin "$REF" > /dev/null 2>&1 && REMOTE_REF_EXISTS="true"
@@ -53,7 +57,7 @@ runs:
                   continue
                 }
               fi
-              git push origin "$REF" && { REMOTE_REF_EXISTS="true"; break; }
+              git push origin "$REF" && { REMOTE_REF_EXISTS="true"; PUSH_SUCCESS="true"; break; }
             else
               git pull --rebase || {
                 echo "Rebase conflict on attempt $attempt — aborting rebase and retrying"
@@ -61,13 +65,15 @@ runs:
                 sleep $((attempt * 2))
                 continue
               }
-              git push && break
-            fi
-            if [ "$attempt" -eq "$MAX_RETRIES" ]; then
-              echo "::error::Failed to push after $MAX_RETRIES attempts"
-              exit 1
+              git push && { PUSH_SUCCESS="true"; break; }
             fi
             echo "Push failed on attempt $attempt, retrying..."
             sleep $((attempt * 2))
           done
+          # Restore stashed unstaged changes
+          git stash pop 2>/dev/null || true
+          if [ "$PUSH_SUCCESS" != "true" ]; then
+            echo "::error::Failed to push after $MAX_RETRIES attempts"
+            exit 1
+          fi
         fi

package/src/scripts/push-to-logs.sh

@@ -29,6 +29,10 @@ fi
 
 echo "push-to-logs: pushing ${FILES[*]} to ${BRANCH}"
 
+# Mark the workspace as safe (needed in container jobs where the checkout
+# was done by a different user, e.g. Playwright containers)
+git config --global --add safe.directory "$(pwd)" 2>/dev/null || true
+
 # Configure git
 git config --local user.email 'action@github.com'
 git config --local user.name 'GitHub Actions[bot]'
@@ -39,13 +43,21 @@ for f in "${FILES[@]}"; do
   cp "$f" "${TMPDIR}/$(basename "$f")"
 done
 
+# Remember which branch/ref to return to
+ORIGINAL_REF=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
+if [ "$ORIGINAL_REF" = "HEAD" ]; then
+  ORIGINAL_REF=$(git rev-parse HEAD 2>/dev/null || echo "")
+fi
+
+# Stash any uncommitted changes so branch switching works cleanly
+git stash --include-untracked 2>/dev/null || true
+
 # Fetch the agentic-lib-logs branch (may not exist yet)
 REMOTE_EXISTS=""
 git fetch origin "${BRANCH}" 2>/dev/null && REMOTE_EXISTS="true" || true
 
 if [ "$REMOTE_EXISTS" = "true" ]; then
-  # Check out existing agentic-lib-logs branch into a detached worktree-like state
-  git checkout "origin/${BRANCH}" -- . 2>/dev/null || true
+  # Check out existing agentic-lib-logs branch
   git checkout -B "${BRANCH}" "origin/${BRANCH}"
 else
   # Create orphan branch
@@ -79,8 +91,15 @@ else
   done
 fi
 
-# Return to previous branch
-git checkout - 2>/dev/null || git checkout main 2>/dev/null || true
+# Return to original branch/ref
+if [ -n "$ORIGINAL_REF" ]; then
+  git checkout "$ORIGINAL_REF" 2>/dev/null || git checkout main 2>/dev/null || true
+else
+  git checkout main 2>/dev/null || true
+fi
+
+# Restore stashed changes
+git stash pop 2>/dev/null || true
 
 # Clean up
 rm -rf "$TMPDIR"

package/src/seeds/missions/agi.md

@@ -0,0 +1,22 @@
+# Mission
+
+**Agentic-lib** is evolving into an intelligent automation system endowed with multiple AGI-aligned capabilities, all oriented toward a coherent long-term purpose: enabling agentic, cross-repository intelligent automation. The ultimate vision is a network of self-managing coding agents that can understand high-level goals, break them down, execute tasks across many projects, learn from their experiences, and seek assistance when needed – all with minimal human intervention. Each of the new features (Memory, Planning, Goal Decomposition, Self-Improvement, Replication, and Help-Seeking) contributes to this vision in a concrete, feasible way, building the stepping stones toward a truly autonomous development workflow.
+
+In the near term, these traits function as enhancements to the JavaScript CLI/Lambda agent that drives **agentic-lib**:
+- **Memory** provides continuity. The agent now retains a log of actions and outcomes, which means it can carry context from one step to the next. This is immediately useful for avoiding redundant operations and will later allow experience-based learning. For example, when the agent works on Repository A and then on Repository B, a memory of patterns or solutions from A could inform its actions on B.
+- **Planning** gives the agent foresight. Instead of reacting to one command at a time, it can map out a sequence of tasks to achieve a bigger objective. Right now it executes those plans instantly, but this capability will expand to planning over longer durations (even across workflow runs) and coordinating complex changes (like a multi-step refactor that touches many parts of a codebase or multiple repositories).
+- **Goal Decomposition** adds transparency and manageability to complex objectives. The agent can articulate a game plan (a set of sub-tasks) for a broad goal, which can be reviewed or assigned out. In a multi-repository scenario, the agent might decompose a company-wide objective into repo-specific tasks. This structured breakdown makes large-scale automation safer and more organized, since each piece can be tracked (potentially as separate issues or pull requests).
+- **Self-Improvement** makes the agent reflective. By tracking its performance (how many errors, how fast it completes tasks) the agent lays the groundwork for optimizing itself. In the short run, this means better observability and diagnostics in the system. In the long run, the agent could use this information to autonomously fine-tune its own algorithms – for instance, detecting that it often fails a certain kind of task and adjusting its approach or updating its code. This trait keeps the agent aligned with best practices and efficiency as it scales up.
+- **Replication** unlocks scale. The agent is no longer a singleton processing one item at a time – it can replicate its effort either through parallel processing or by spawning new agent instances. Immediately, this manifests as parallel command execution which speeds up workflows (e.g., running multiple checks or updates simultaneously). Looking forward, replication means the agentic-lib model can be instantiated in multiple environments at once: think of dozens of agent clones each working on a different repository but sharing the same core knowledge. This horizontal scaling is essential for cross-repository automation in large organizations.
+- **Help-Seeking** keeps the agent humble and effective. When the agent encounters something it doesn’t know, it can ask an external AI or resource, rather than stalling or guessing wrongly. Currently, this is achieved via OpenAI API calls for answers. As this feature matures, the agent will integrate more sources (documentation, human feedback) and become increasingly adept at knowing when and how to seek help. This ensures that as the agent’s autonomy grows, it remains grounded and correct in its actions, leveraging the broader world’s knowledge.
+
+All these capabilities align to serve a **unified mission**: an autonomous system that can handle the lifecycle of software development tasks across multiple projects. Concretely, we are moving toward a scenario where you could give the agent a high-level directive (for example, “ensure all our repositories are using the latest version of library X and adhere to security policy Y”), and the agent would:
+1. **Understand and Plan:** It would use Goal Decomposition and Planning to figure out what needs to be done for each repository – maybe creating a checklist per repository.
+2. **Take Action in Parallel:** Using Replication, it would initiate changes in multiple repositories at once (branching, editing files, running tests), using memory to avoid repeating known fixes and using its plan as a guide.
+3. **Learn and Adapt:** Throughout, Self-Improvement metrics would monitor which repos encountered issues (maybe some tests failed or some had edge cases). The agent could adjust its approach repository by repository – for instance, if it learned a better fix in one place, Memory would carry that knowledge to the others.
+4. **Seek Guidance if Stuck:** If a particular repository has an unusual setup that the agent doesn’t understand, the Help-Seeking trait would kick in – the agent might query documentation or even open a “help needed” issue for a human maintainer, ensuring that it doesn’t silently fail.
+5. **Deliver Results:** Finally, the agent would open pull requests or issues summarizing changes for each repository (or automatically merge them if permitted), effectively executing a coordinated cross-repo update with minimal human oversight.
+
+The long-term purpose is ambitious but grounded in these tangible capabilities. Each new feature is a **plausible next step**: for example, after implementing basic memory, the next step is to make that memory persistent or sharable among agent instances (so that one agent’s learnings become every agent’s knowledge). After introducing planning and decomposition, the next step is to integrate those with the GitHub issue workflow – the agent could start creating and managing issues on its own to track sub-tasks. Self-improvement opens the door to techniques like on-the-fly model prompting (the agent asking “how can I do this better?” and applying the advice). Replication will eventually entail deploying the agent as a service or container that can be instantiated on demand for whatever project needs it. And help-seeking will evolve into a rich web of integrations with documentation, Q&A forums, and direct human loop-ins when necessary.
+
+In summary, the trajectory defined in this feature set steers **agentic-lib** toward becoming a general-purpose automation AI for software projects. It’s not science fiction – each step is achievable with incremental improvements and integrations, and together they compound into a system that can handle increasing complexity. By focusing on feasible enhancements now (like logging memory, adding parallelism, using an API for help, etc.), we ensure that future leaps (like autonomous multi-repo refactoring or self-directed learning) are built on solid ground. All traits work in concert: memory and help-seeking ensure it has the knowledge, planning and decomposition give it strategy, replication gives it manpower, and self-improvement ensures it keeps getting better. With these aligned, **agentic-lib** can truly fulfill its mission of agentic, cross-repository intelligent automation – a stepping stone toward the broader vision of self-evolving code.

package/src/seeds/missions/ascii-face.md

@@ -0,0 +1,4 @@
+# Mission
+
+Create a CLI app that depicts emotion using facial expressions using ascii art.
+This will be the emotion communication mechanism for an AI.

package/src/seeds/missions/hello-world.md

@@ -0,0 +1,3 @@
+# Mission
+
+Deliver the traditional first program to write in a new language, the "Hello World!" message.

package/src/seeds/missions/json-schema-diff.md

@@ -0,0 +1,4 @@
+# Mission
+
+**json‑schema‑diff** is designed to help API developers and teams track and validate changes in JSON Schemas. 
+By providing a human‑readable diff, the tool simplifies the evolution of API definitions and facilitates collaboration during version upgrades.

package/src/seeds/zero-package.json

@@ -17,7 +17,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@xn-intenton-z2a/agentic-lib": "^7.3.0"
+    "@xn-intenton-z2a/agentic-lib": "^7.4.1"
   },
   "devDependencies": {
     "@playwright/test": "^1.58.0",

package/src/seeds/zero-MISSION-empty.md

@@ -1,3 +0,0 @@
-# Mission
-
-Describe your project's mission here. The agentic workflows will evolve `src/lib/main.js` to fulfil this mission.