weyaw 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jasonzwu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+# Weyaw
+
+Weyaw is a local, artifact-backed workflow for agent work.
+
+It exists for projects where agent work should be resumable, inspectable, and grounded in project files rather than scattered across chat history. Weyaw keeps the work loop small: define the intention, record the plan, execute with evidence, verify the result, and preserve useful knowledge for future agents.
+
+## Motivation
+
+Agent sessions are good at local reasoning, but they are easy to interrupt and hard to audit after the fact. Weyaw treats agent work as a project artifact:
+
+- Tasks have durable state and lifecycle.
+- Plans, execution notes, verification, and summaries are written down.
+- Project guidance stays close to the code.
+- Work can be resumed without reconstructing context from memory.
+
+The goal is not to replace human judgment or turn every change into process. The goal is to make non-trivial agent work easier to continue, review, and trust.
+
+## Scope
+
+Weyaw supports today:
+
+- Local project onboarding and task routing.
+- Persistent task artifacts for plan, execution, verification, review, and consolidation.
+- Project-scoped agent skills for common workflow actions.
+- Roadmap and blueprint notes for project direction and design decisions.
+- Health checks for workflow artifact consistency.
+- Local management for incremental todo work through the project workflow workspace, normally `.aw`, plus constraints, process records, and task state.
+
+Weyaw has growing support for:
+
+- A read-only dashboard for inspecting workflow state.
+- Agent coordination and longer main/worker flows when they fit the artifact-backed workflow.
+
+Weyaw is planned to support:
+
+- Local indexing or retrieval over existing code, specs, roadmap, and retained knowledge outside the active task loop.
+- Project-management views over retained project artifacts beyond the current task loop.
+
+Weyaw does not try to be:
+
+- A replacement for Git history or normal source-control practice.
+
+## Common Skills
+
+Use these prompts from an agent session in a Weyaw project:
+
+```text
+$aw-init <project context>
+$aw <task intention>
+$aw-resume <task-id>
+$aw-status
+$aw-help
+$aw-health
+$aw-blueprint <design or standards update>
+$aw-roadmap <roadmap update>
+```
+
+Typical use:
+
+- `$aw-init` establishes or reconciles project context.
+- `$aw` starts scoped task work from an intention.
+- `$aw-resume` continues recorded work.
+- `$aw-status` reports current workflow state.
+- `$aw-help` suggests the next useful Weyaw action.
+- `$aw-health` checks or repairs workflow consistency.
+- `$aw-blueprint` updates durable design language or standards.
+- `$aw-roadmap` updates project direction without starting implementation.
+
+## Installation
+
+Requires [Node.js](https://nodejs.org/) 18+.
+
+```bash
+npm install -g weyaw
+```
+
+The correct pre-built binary for your platform is installed automatically.
+No Rust toolchain needed. Verify with `aw --help`.
+
+See [Getting Started](docs/getting-started.md) for full details and first
+steps.
+
+## Documentation
+
+- [Getting Started](docs/getting-started.md)
+- [Concepts](docs/concepts.md)
+- [CLI](docs/cli.md)
+- [Skills](docs/skills.md)
+- [Artifacts](docs/artifacts.md)
+- [Dashboard](docs/dashboard.md)
+- [Release](docs/release.md)
+
+## Design Principles
+
+- Keep workflow state local to the project.
+- Prefer small, explicit task steps over hidden agent memory.
+- Record evidence for changes that matter.
+- Keep human decisions visible.
+- Treat generated and runtime artifacts as separate from source design.
+
+## Development
+
+This repository uses Rust 1.96.0. When `rustup` is installed, it reads
+`rust-toolchain.toml` and selects the project toolchain automatically.
+
+Run the focused local checks before handing off Rust changes:
+
+```text
+cargo fmt --check
+cargo test --locked --all-targets
+```
+
+### Npm Package
+
+The npm metadata in this repository exposes the Rust command as `aw`. The
+package remains private/local at this stage and can be linked globally for
+local use.
+
+Run the focused package checks with:
+
+```text
+npm run package:metadata-test
+npm run package:smoke
+```

package/bin/aw.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const args = process.argv.slice(2);
+const exeSuffix = process.platform === 'win32' ? '.exe' : '';
+
+// Map (platform, arch) to the platform package name
+const PLATFORM_PACKAGES = {
+  'linux-x64': 'weyaw-linux-x64',
+  'darwin-arm64': 'weyaw-darwin-arm64',
+  'win32-x64': 'weyaw-win32-x64',
+};
+
+function resolvePlatformBinary() {
+  const key = `${process.platform}-${process.arch}`;
+  const pkgName = PLATFORM_PACKAGES[key];
+  if (!pkgName) return null;
+
+  try {
+    // require.resolve follows Node's module resolution into node_modules
+    const pkgJson = require.resolve(`${pkgName}/package.json`);
+    return path.join(path.dirname(pkgJson), `aw${exeSuffix}`);
+  } catch {
+    return null;
+  }
+}
+
+// Dev-mode fallback: look for a locally-built binary in the source tree
+function resolveLocalBinary() {
+  const packageRoot = path.resolve(__dirname, '..');
+  const candidates = [
+    process.env.WEYAW_RS_BIN,
+    path.join(packageRoot, 'target', 'release', `aw${exeSuffix}`),
+    path.join(packageRoot, 'target', 'debug', `aw${exeSuffix}`),
+  ].filter(Boolean);
+
+  return candidates.find((p) => fs.existsSync(p)) || null;
+}
+
+function run(command, childArgs, options = {}) {
+  const result = spawnSync(command, childArgs, { stdio: 'inherit', ...options });
+
+  if (result.error) {
+    console.error(`aw: failed to launch ${command}: ${result.error.message}`);
+    if (result.error.code === 'ENOENT' && command === 'cargo') {
+      console.error('aw: install Rust/Cargo or set WEYAW_RS_BIN to an aw executable.');
+    }
+    process.exit(result.error.code === 'ENOENT' ? 127 : 1);
+  }
+
+  if (result.signal) {
+    try { process.kill(process.pid, result.signal); } catch { /* noop */ }
+    process.exit(1);
+  }
+
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+// 1. Try platform package
+const platformBin = resolvePlatformBinary();
+if (platformBin && fs.existsSync(platformBin)) {
+  run(platformBin, args);
+}
+
+// 2. Try local build (dev mode)
+const localBin = resolveLocalBinary();
+if (localBin) {
+  run(localBin, args);
+}
+
+// 3. Fall back to cargo run (dev mode without pre-built binary)
+const packageRoot = path.resolve(__dirname, '..');
+if (fs.existsSync(path.join(packageRoot, 'Cargo.toml'))) {
+  run('cargo', ['run', '--locked', '--bin', 'aw', '--', ...args], { cwd: packageRoot });
+}
+
+console.error('aw: no binary found. Install with: npm install -g weyaw');
+process.exit(1);

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "weyaw",
+  "version": "0.1.0",
+  "description": "Weyaw artifact-backed workflow CLI and local server",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsnzwu/weyaw.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jsnzwu/weyaw/issues"
+  },
+  "homepage": "https://github.com/jsnzwu/weyaw#readme",
+  "bin": {
+    "aw": "bin/aw.js"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "optionalDependencies": {
+    "weyaw-linux-x64": "0.1.0",
+    "weyaw-darwin-arm64": "0.1.0",
+    "weyaw-win32-x64": "0.1.0"
+  },
+  "scripts": {
+    "package:metadata-test": "node tests/package_metadata.test.js",
+    "package:smoke": "node bin/aw.js --help || test $? -eq 2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "workflow",
+    "agents",
+    "cli",
+    "rust"
+  ]
+}